fix(region): record sync cost time

pkg/compute/models/cloudproviderregions.go

@@ -349,12 +349,46 @@ func (self *SCloudproviderregion) cancelStartingSync(userCred mcclient.TokenCred
 	return nil
 }
 
-type SSyncResultSet map[string]*compare.SyncResult
+type SyncResult struct {
+	RequestCost string
+	rc          time.Duration
+	SqlCost     string
+	sc          time.Duration
+	compare.SyncResult
+}
+
+type SSyncResultSet map[string]*SyncResult
+
+func (set SSyncResultSet) AddRequestCost(manager db.IModelManager) func() {
+	start := time.Now()
+	key := manager.KeywordPlural()
+	if _, ok := set[key]; !ok {
+		set[key] = &SyncResult{}
+	}
+	res := set[key]
+	return func() {
+		res.rc += time.Since(start)
+		res.RequestCost = res.rc.String()
+	}
+}
+
+func (set SSyncResultSet) AddSqlCost(manager db.IModelManager) func() {
+	start := time.Now()
+	key := manager.KeywordPlural()
+	if _, ok := set[key]; !ok {
+		set[key] = &SyncResult{}
+	}
+	res := set[key]
+	return func() {
+		res.sc += time.Since(start)
+		res.SqlCost = res.sc.String()
+	}
+}
 
 func (set SSyncResultSet) Add(manager db.IModelManager, result compare.SyncResult) {
 	key := manager.KeywordPlural()
 	if _, ok := set[key]; !ok {
-		set[key] = &compare.SyncResult{}
+		set[key] = &SyncResult{}
 	}
 	res := set[key]
 	res.AddCnt += result.AddCnt

pkg/compute/models/cloudsync.go

@@ -89,13 +89,19 @@ func isInCache(pairs []sStoragecacheSyncPair, localCacheId string) bool {
 }
 
 func syncRegionQuotas(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, driver cloudprovider.ICloudProvider, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	quotas, err := remoteRegion.GetICloudQuotas()
+	quotas, err := func() ([]cloudprovider.ICloudQuota, error) {
+		defer syncResults.AddRequestCost(CloudproviderQuotaManager)()
+		return remoteRegion.GetICloudQuotas()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudQuotas for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
-	result := CloudproviderQuotaManager.SyncQuotas(ctx, userCred, provider.GetOwnerId(), provider, localRegion, api.CLOUD_PROVIDER_QUOTA_RANGE_CLOUDREGION, quotas)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(CloudproviderQuotaManager)()
+		return CloudproviderQuotaManager.SyncQuotas(ctx, userCred, provider.GetOwnerId(), provider, localRegion, api.CLOUD_PROVIDER_QUOTA_RANGE_CLOUDREGION, quotas)
+	}()
 	syncResults.Add(CloudproviderQuotaManager, result)
 	msg := result.Result()
 	notes := fmt.Sprintf("SyncQuotas for region %s result: %s", localRegion.Name, msg)
@@ -107,13 +113,19 @@ func syncRegionQuotas(ctx context.Context, userCred mcclient.TokenCredential, sy
 }
 
 func syncRegionZones(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) ([]SZone, []cloudprovider.ICloudZone, error) {
-	zones, err := remoteRegion.GetIZones()
+	zones, err := func() ([]cloudprovider.ICloudZone, error) {
+		defer syncResults.AddRequestCost(ZoneManager)()
+		return remoteRegion.GetIZones()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetZones for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return nil, nil, err
 	}
-	localZones, remoteZones, result := ZoneManager.SyncZones(ctx, userCred, localRegion, zones)
+	localZones, remoteZones, result := func() ([]SZone, []cloudprovider.ICloudZone, compare.SyncResult) {
+		defer syncResults.AddSqlCost(ZoneManager)()
+		return ZoneManager.SyncZones(ctx, userCred, localRegion, zones)
+	}()
 	syncResults.Add(ZoneManager, result)
 	msg := result.Result()
 	notes := fmt.Sprintf("SyncZones for region %s result: %s", localRegion.Name, msg)
@@ -169,14 +181,20 @@ func syncRegionSkus(ctx context.Context, userCred mcclient.TokenCredential, loca
 }
 
 func syncRegionEips(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	eips, err := remoteRegion.GetIEips()
+	eips, err := func() ([]cloudprovider.ICloudEIP, error) {
+		defer syncResults.AddRequestCost(ElasticipManager)()
+		return remoteRegion.GetIEips()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIEips for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := ElasticipManager.SyncEips(ctx, userCred, provider, localRegion, eips, provider.GetOwnerId())
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(ElasticipManager)()
+		return ElasticipManager.SyncEips(ctx, userCred, provider, localRegion, eips, provider.GetOwnerId())
+	}()
 
 	syncResults.Add(ElasticipManager, result)
 
@@ -189,14 +207,20 @@ func syncRegionEips(ctx context.Context, userCred mcclient.TokenCredential, sync
 }
 
 func syncRegionBuckets(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) {
-	buckets, err := remoteRegion.GetIBuckets()
+	buckets, err := func() ([]cloudprovider.ICloudBucket, error) {
+		defer syncResults.AddRequestCost(BucketManager)()
+		return remoteRegion.GetIBuckets()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIBuckets for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := BucketManager.syncBuckets(ctx, userCred, provider, localRegion, buckets)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(BucketManager)()
+		return BucketManager.syncBuckets(ctx, userCred, provider, localRegion, buckets)
+	}()
 
 	syncResults.Add(BucketManager, result)
 
@@ -211,14 +235,20 @@ func syncRegionBuckets(ctx context.Context, userCred mcclient.TokenCredential, s
 }
 
 func syncRegionVPCs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	vpcs, err := remoteRegion.GetIVpcs()
+	vpcs, err := func() ([]cloudprovider.ICloudVpc, error) {
+		defer syncResults.AddRequestCost(VpcManager)()
+		return remoteRegion.GetIVpcs()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetVpcs for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	localVpcs, remoteVpcs, result := VpcManager.SyncVPCs(ctx, userCred, provider, localRegion, vpcs)
+	localVpcs, remoteVpcs, result := func() ([]SVpc, []cloudprovider.ICloudVpc, compare.SyncResult) {
+		defer syncResults.AddSqlCost(VpcManager)()
+		return VpcManager.SyncVPCs(ctx, userCred, provider, localRegion, vpcs)
+	}()
 
 	syncResults.Add(VpcManager, result)
 
@@ -252,7 +282,10 @@ func syncRegionVPCs(ctx context.Context, userCred mcclient.TokenCredential, sync
 }
 
 func syncRegionAccessGroups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	accessGroups, err := remoteRegion.GetICloudAccessGroups()
+	accessGroups, err := func() ([]cloudprovider.ICloudAccessGroup, error) {
+		defer syncResults.AddRequestCost(AccessGroupManager)()
+		return remoteRegion.GetICloudAccessGroups()
+	}()
 	if err != nil {
 		if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported {
 			return
@@ -261,13 +294,19 @@ func syncRegionAccessGroups(ctx context.Context, userCred mcclient.TokenCredenti
 		return
 	}
 
-	result := localRegion.SyncAccessGroups(ctx, userCred, provider, accessGroups)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(AccessGroupManager)()
+		return localRegion.SyncAccessGroups(ctx, userCred, provider, accessGroups)
+	}()
 	syncResults.Add(AccessGroupCacheManager, result)
 	log.Infof("Sync Access Group Caches for region %s result: %s", localRegion.Name, result.Result())
 }
 
 func syncRegionFileSystems(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	filesystems, err := remoteRegion.GetICloudFileSystems()
+	filesystems, err := func() ([]cloudprovider.ICloudFileSystem, error) {
+		defer syncResults.AddRequestCost(FileSystemManager)()
+		return remoteRegion.GetICloudFileSystems()
+	}()
 	if err != nil {
 		if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported {
 			return
@@ -276,7 +315,10 @@ func syncRegionFileSystems(ctx context.Context, userCred mcclient.TokenCredentia
 		return
 	}
 
-	localFSs, removeFSs, result := localRegion.SyncFileSystems(ctx, userCred, provider, filesystems)
+	localFSs, removeFSs, result := func() ([]SFileSystem, []cloudprovider.ICloudFileSystem, compare.SyncResult) {
+		defer syncResults.AddSqlCost(FileSystemManager)()
+		return localRegion.SyncFileSystems(ctx, userCred, provider, filesystems)
+	}()
 	syncResults.Add(FileSystemManager, result)
 	log.Infof("Sync FileSystem for region %s result: %s", localRegion.Name, result.Result())
 
@@ -309,7 +351,10 @@ func syncFileSystemMountTargets(ctx context.Context, userCred mcclient.TokenCred
 }
 
 func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) {
-	peerConnections, err := remoteVpc.GetICloudVpcPeeringConnections()
+	peerConnections, err := func() ([]cloudprovider.ICloudVpcPeeringConnection, error) {
+		defer syncResults.AddRequestCost(VpcPeeringConnectionManager)()
+		return remoteVpc.GetICloudVpcPeeringConnections()
+	}()
 	if err != nil {
 		if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported {
 			return
@@ -318,10 +363,16 @@ func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredenti
 		return
 	}
 
-	result := localVpc.SyncVpcPeeringConnections(ctx, userCred, peerConnections)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(VpcPeeringConnectionManager)()
+		return localVpc.SyncVpcPeeringConnections(ctx, userCred, peerConnections)
+	}()
 	syncResults.Add(VpcPeeringConnectionManager, result)
 
-	accepterPeerings, err := remoteVpc.GetICloudAccepterVpcPeeringConnections()
+	accepterPeerings, err := func() ([]cloudprovider.ICloudVpcPeeringConnection, error) {
+		defer syncResults.AddRequestCost(VpcPeeringConnectionManager)()
+		return remoteVpc.GetICloudAccepterVpcPeeringConnections()
+	}()
 	if err != nil {
 		if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported {
 			return
@@ -329,7 +380,10 @@ func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredenti
 		log.Errorf("GetICloudVpcPeeringConnections for vpc %s failed %v", localVpc.Name, err)
 		return
 	}
-	backSyncResult := localVpc.BackSycVpcPeeringConnectionsVpc(accepterPeerings)
+	backSyncResult := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(VpcPeeringConnectionManager)()
+		return localVpc.BackSycVpcPeeringConnectionsVpc(accepterPeerings)
+	}()
 	syncResults.Add(VpcPeeringConnectionManager, backSyncResult)
 
 	log.Infof("SyncVpcPeeringConnections for vpc %s result: %s", localVpc.Name, result.Result())
@@ -339,14 +393,20 @@ func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredenti
 }
 
 func syncVpcSecGroup(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) {
-	secgroups, err := remoteVpc.GetISecurityGroups()
+	secgroups, err := func() ([]cloudprovider.ICloudSecurityGroup, error) {
+		defer syncResults.AddRequestCost(SecurityGroupManager)()
+		return remoteVpc.GetISecurityGroups()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetISecurityGroups for vpc %s failed %s", remoteVpc.GetId(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	_, _, result := SecurityGroupCacheManager.SyncSecurityGroupCaches(ctx, userCred, provider, secgroups, localVpc)
+	_, _, result := func() ([]SSecurityGroup, []cloudprovider.ICloudSecurityGroup, compare.SyncResult) {
+		defer syncResults.AddSqlCost(SecurityGroupManager)()
+		return SecurityGroupCacheManager.SyncSecurityGroupCaches(ctx, userCred, provider, secgroups, localVpc)
+	}()
 	syncResults.Add(SecurityGroupCacheManager, result)
 
 	msg := result.Result()
@@ -358,13 +418,19 @@ func syncVpcSecGroup(ctx context.Context, userCred mcclient.TokenCredential, syn
 }
 
 func syncVpcRouteTables(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) {
-	routeTables, err := remoteVpc.GetIRouteTables()
+	routeTables, err := func() ([]cloudprovider.ICloudRouteTable, error) {
+		defer syncResults.AddRequestCost(RouteTableManager)()
+		return remoteVpc.GetIRouteTables()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIRouteTables for vpc %s failed %s", remoteVpc.GetId(), err)
 		log.Errorf(msg)
 		return
 	}
-	localRouteTables, remoteRouteTables, result := RouteTableManager.SyncRouteTables(ctx, userCred, localVpc, routeTables, provider)
+	localRouteTables, remoteRouteTables, result := func() ([]SRouteTable, []cloudprovider.ICloudRouteTable, compare.SyncResult) {
+		defer syncResults.AddSqlCost(RouteTableManager)()
+		return RouteTableManager.SyncRouteTables(ctx, userCred, localVpc, routeTables, provider)
+	}()
 
 	syncResults.Add(RouteTableManager, result)
 
@@ -389,13 +455,19 @@ func syncVpcRouteTables(ctx context.Context, userCred mcclient.TokenCredential,
 }
 
 func syncVpcNatgateways(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) {
-	natGateways, err := remoteVpc.GetINatGateways()
+	natGateways, err := func() ([]cloudprovider.ICloudNatGateway, error) {
+		defer syncResults.AddRequestCost(NatGatewayManager)()
+		return remoteVpc.GetINatGateways()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetINatGateways for vpc %s failed %s", remoteVpc.GetId(), err)
 		log.Errorf(msg)
 		return
 	}
-	localNatGateways, remoteNatGateways, result := NatGatewayManager.SyncNatGateways(ctx, userCred, provider.GetOwnerId(), provider, localVpc, natGateways)
+	localNatGateways, remoteNatGateways, result := func() ([]SNatGateway, []cloudprovider.ICloudNatGateway, compare.SyncResult) {
+		defer syncResults.AddSqlCost(NatGatewayManager)()
+		return NatGatewayManager.SyncNatGateways(ctx, userCred, provider.GetOwnerId(), provider, localVpc, natGateways)
+	}()
 
 	syncResults.Add(NatGatewayManager, result)
 
@@ -471,13 +543,27 @@ func syncNatSTable(ctx context.Context, userCred mcclient.TokenCredential, provi
 }
 
 func syncVpcWires(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) {
-	wires, err := remoteVpc.GetIWires()
+	wires, err := func() ([]cloudprovider.ICloudWire, error) {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddRequestCost(WireManager)()
+			}
+		}()
+		return remoteVpc.GetIWires()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIWires for vpc %s failed %s", remoteVpc.GetId(), err)
 		log.Errorf(msg)
 		return
 	}
-	localWires, remoteWires, result := WireManager.SyncWires(ctx, userCred, localVpc, wires, provider)
+	localWires, remoteWires, result := func() ([]SWire, []cloudprovider.ICloudWire, compare.SyncResult) {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddSqlCost(WireManager)()
+			}
+		}()
+		return WireManager.SyncWires(ctx, userCred, localVpc, wires, provider)
+	}()
 
 	if syncResults != nil {
 		syncResults.Add(WireManager, result)
@@ -505,13 +591,27 @@ func syncVpcWires(ctx context.Context, userCred mcclient.TokenCredential, syncRe
 }
 
 func syncWireNetworks(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localWire *SWire, remoteWire cloudprovider.ICloudWire, syncRange *SSyncRange) {
-	nets, err := remoteWire.GetINetworks()
+	nets, err := func() ([]cloudprovider.ICloudNetwork, error) {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddRequestCost(NetworkManager)()
+			}
+		}()
+		return remoteWire.GetINetworks()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetINetworks for wire %s failed %s", remoteWire.GetId(), err)
 		log.Errorf(msg)
 		return
 	}
-	_, _, result := NetworkManager.SyncNetworks(ctx, userCred, localWire, nets, provider)
+	_, _, result := func() ([]SNetwork, []cloudprovider.ICloudNetwork, compare.SyncResult) {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddSqlCost(NetworkManager)()
+			}
+		}()
+		return NetworkManager.SyncNetworks(ctx, userCred, localWire, nets, provider)
+	}()
 
 	if syncResults != nil {
 		syncResults.Add(NetworkManager, result)
@@ -528,13 +628,19 @@ func syncWireNetworks(ctx context.Context, userCred mcclient.TokenCredential, sy
 }
 
 func syncZoneStorages(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localZone *SZone, remoteZone cloudprovider.ICloudZone, syncRange *SSyncRange, storageCachePairs []sStoragecacheSyncPair) []sStoragecacheSyncPair {
-	storages, err := remoteZone.GetIStorages()
+	storages, err := func() ([]cloudprovider.ICloudStorage, error) {
+		defer syncResults.AddRequestCost(StorageManager)()
+		return remoteZone.GetIStorages()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIStorages for zone %s failed %s", remoteZone.GetName(), err)
 		log.Errorf(msg)
 		return nil
 	}
-	localStorages, remoteStorages, result := StorageManager.SyncStorages(ctx, userCred, provider, localZone, storages)
+	localStorages, remoteStorages, result := func() ([]SStorage, []cloudprovider.ICloudStorage, compare.SyncResult) {
+		defer syncResults.AddSqlCost(StorageManager)()
+		return StorageManager.SyncStorages(ctx, userCred, provider, localZone, storages)
+	}()
 
 	syncResults.Add(StorageManager, result)
 
@@ -597,13 +703,19 @@ func syncStorageCaches(ctx context.Context, userCred mcclient.TokenCredential, p
 }
 
 func syncStorageDisks(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localStorage *SStorage, remoteStorage cloudprovider.ICloudStorage, syncRange *SSyncRange) {
-	disks, err := remoteStorage.GetIDisks()
+	disks, err := func() ([]cloudprovider.ICloudDisk, error) {
+		defer syncResults.AddRequestCost(DiskManager)()
+		return remoteStorage.GetIDisks()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIDisks for storage %s failed %s", remoteStorage.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
-	_, _, result := DiskManager.SyncDisks(ctx, userCred, driver, localStorage, disks, provider.GetOwnerId())
+	_, _, result := func() ([]SDisk, []cloudprovider.ICloudDisk, compare.SyncResult) {
+		defer syncResults.AddSqlCost(DiskManager)()
+		return DiskManager.SyncDisks(ctx, userCred, driver, localStorage, disks, provider.GetOwnerId())
+	}()
 
 	syncResults.Add(DiskManager, result)
 
@@ -618,13 +730,19 @@ func syncStorageDisks(ctx context.Context, userCred mcclient.TokenCredential, sy
 }
 
 func syncZoneHosts(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localZone *SZone, remoteZone cloudprovider.ICloudZone, syncRange *SSyncRange, storageCachePairs []sStoragecacheSyncPair) []sStoragecacheSyncPair {
-	hosts, err := remoteZone.GetIHosts()
+	hosts, err := func() ([]cloudprovider.ICloudHost, error) {
+		defer syncResults.AddRequestCost(HostManager)()
+		return remoteZone.GetIHosts()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIHosts for zone %s failed %s", remoteZone.GetName(), err)
 		log.Errorf(msg)
 		return nil
 	}
-	localHosts, remoteHosts, result := HostManager.SyncHosts(ctx, userCred, provider, localZone, hosts)
+	localHosts, remoteHosts, result := func() ([]SHost, []cloudprovider.ICloudHost, compare.SyncResult) {
+		defer syncResults.AddSqlCost(HostManager)()
+		return HostManager.SyncHosts(ctx, userCred, provider, localZone, hosts)
+	}()
 
 	syncResults.Add(HostManager, result)
 
@@ -659,15 +777,21 @@ func syncZoneHosts(ctx context.Context, userCred mcclient.TokenCredential, syncR
 }
 
 func syncHostStorages(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localHost *SHost, remoteHost cloudprovider.ICloudHost, storageCachePairs []sStoragecacheSyncPair) []sStoragecacheSyncPair {
-	storages, err := remoteHost.GetIStorages()
+	storages, err := func() ([]cloudprovider.ICloudStorage, error) {
+		defer syncResults.AddRequestCost(HoststorageManager)()
+		return remoteHost.GetIStorages()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIStorages for host %s failed %s", remoteHost.GetName(), err)
 		log.Errorf(msg)
 		return nil
 	}
-	localStorages, remoteStorages, result := localHost.SyncHostStorages(ctx, userCred, storages, provider)
+	localStorages, remoteStorages, result := func() ([]SStorage, []cloudprovider.ICloudStorage, compare.SyncResult) {
+		defer syncResults.AddSqlCost(HoststorageManager)()
+		return localHost.SyncHostStorages(ctx, userCred, storages, provider)
+	}()
 
-	syncResults.Add(StorageManager, result)
+	syncResults.Add(HoststorageManager, result)
 
 	msg := result.Result()
 	notes := fmt.Sprintf("SyncHostStorages for host %s result: %s", localHost.Name, msg)
@@ -692,16 +816,30 @@ func syncHostStorages(ctx context.Context, userCred mcclient.TokenCredential, sy
 }
 
 func syncHostWires(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localHost *SHost, remoteHost cloudprovider.ICloudHost) {
-	wires, err := remoteHost.GetIWires()
+	wires, err := func() ([]cloudprovider.ICloudWire, error) {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddRequestCost(HostwireManager)()
+			}
+		}()
+		return remoteHost.GetIWires()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIWires for host %s failed %s", remoteHost.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
-	result := localHost.SyncHostWires(ctx, userCred, wires)
+	result := func() compare.SyncResult {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddSqlCost(HostwireManager)()
+			}
+		}()
+		return localHost.SyncHostWires(ctx, userCred, wires)
+	}()
 
 	if syncResults != nil {
-		syncResults.Add(WireManager, result)
+		syncResults.Add(HostwireManager, result)
 	}
 
 	msg := result.Result()
@@ -715,13 +853,20 @@ func syncHostWires(ctx context.Context, userCred mcclient.TokenCredential, syncR
 }
 
 func syncHostVMs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localHost *SHost, remoteHost cloudprovider.ICloudHost, syncRange *SSyncRange) {
-	vms, err := remoteHost.GetIVMs()
+	vms, err := func() ([]cloudprovider.ICloudVM, error) {
+		defer syncResults.AddRequestCost(GuestManager)()
+		return remoteHost.GetIVMs()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIVMs for host %s failed %s", remoteHost.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
-	syncVMPairs, result := localHost.SyncHostVMs(ctx, userCred, driver, vms, provider.GetOwnerId())
+
+	syncVMPairs, result := func() ([]SGuestSyncResult, compare.SyncResult) {
+		defer syncResults.AddSqlCost(GuestManager)()
+		return localHost.SyncHostVMs(ctx, userCred, driver, vms, provider.GetOwnerId())
+	}()
 
 	syncResults.Add(GuestManager, result)
 
@@ -747,14 +892,9 @@ func syncHostVMs(ctx context.Context, userCred mcclient.TokenCredential, syncRes
 			}
 
 			syncVMPeripherals(ctx, userCred, syncVMPairs[i].Local, syncVMPairs[i].Remote, localHost, provider, driver)
-			// syncMetadata(ctx, userCred, syncVMPairs[i].Local, syncVMPairs[i].Remote)
-			// syncVMNics(ctx, userCred, provider, localHost, syncVMPairs[i].Local, syncVMPairs[i].Remote)
-			// syncVMDisks(ctx, userCred, provider, driver, localHost, syncVMPairs[i].Local, syncVMPairs[i].Remote, syncRange)
-			// syncVMEip(ctx, userCred, provider, syncVMPairs[i].Local, syncVMPairs[i].Remote)
-			// syncVMSecgroups(ctx, userCred, provider, syncVMPairs[i].Local, syncVMPairs[i].Remote)
-
 		}()
 	}
+
 }
 
 func syncVMPeripherals(ctx context.Context, userCred mcclient.TokenCredential, local *SGuest, remote cloudprovider.ICloudVM, host *SHost, provider *SCloudprovider, driver cloudprovider.ICloudProvider) {
@@ -869,13 +1009,19 @@ func syncSkusFromPrivateCloud(ctx context.Context, userCred mcclient.TokenCreden
 }
 
 func syncRegionDBInstances(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	instances, err := remoteRegion.GetIDBInstances()
+	instances, err := func() ([]cloudprovider.ICloudDBInstance, error) {
+		defer syncResults.AddRequestCost(DBInstanceManager)()
+		return remoteRegion.GetIDBInstances()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIDBInstances for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
-	localInstances, remoteInstances, result := DBInstanceManager.SyncDBInstances(ctx, userCred, provider.GetOwnerId(), provider, localRegion, instances)
+	localInstances, remoteInstances, result := func() ([]SDBInstance, []cloudprovider.ICloudDBInstance, compare.SyncResult) {
+		defer syncResults.AddSqlCost(DBInstanceManager)()
+		return DBInstanceManager.SyncDBInstances(ctx, userCred, provider.GetOwnerId(), provider, localRegion, instances)
+	}()
 
 	syncResults.Add(DBInstanceManager, result)
 	DBInstanceManager.SyncDBInstanceMasterId(ctx, userCred, provider, instances)
@@ -898,6 +1044,7 @@ func syncRegionDBInstances(ctx context.Context, userCred mcclient.TokenCredentia
 			syncDBInstanceResource(ctx, userCred, syncResults, &localInstances[i], remoteInstances[i])
 		}()
 	}
+
 }
 
 func syncDBInstanceResource(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SDBInstance, remoteInstance cloudprovider.ICloudDBInstance) {
@@ -998,12 +1145,19 @@ func syncDBInstanceParameters(ctx context.Context, userCred mcclient.TokenCreden
 }
 
 func syncRegionDBInstanceBackups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) error {
-	backups, err := remoteRegion.GetIDBInstanceBackups()
+	backups, err := func() ([]cloudprovider.ICloudDBInstanceBackup, error) {
+		defer syncResults.AddRequestCost(DBInstanceBackupManager)()
+		return remoteRegion.GetIDBInstanceBackups()
+	}()
 	if err != nil {
 		return errors.Wrapf(err, "GetIDBInstanceBackups")
 	}
 
-	result := DBInstanceBackupManager.SyncDBInstanceBackups(ctx, userCred, provider, nil, localRegion, backups)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(DBInstanceBackupManager)()
+		return DBInstanceBackupManager.SyncDBInstanceBackups(ctx, userCred, provider, nil, localRegion, backups)
+	}()
+
 	syncResults.Add(DBInstanceBackupManager, result)
 
 	msg := result.Result()
@@ -1012,7 +1166,6 @@ func syncRegionDBInstanceBackups(ctx context.Context, userCred mcclient.TokenCre
 		return result.AllError()
 	}
 	return nil
-
 }
 
 func syncDBInstanceDatabases(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SDBInstance, remoteInstance cloudprovider.ICloudDBInstance) error {
@@ -1084,13 +1237,21 @@ func syncDBInstanceAccountPrivileges(ctx context.Context, userCred mcclient.Toke
 }
 
 func syncWafIPSets(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	ipSets, err := remoteRegion.GetICloudWafIPSets()
+	ipSets, err := func() ([]cloudprovider.ICloudWafIPSet, error) {
+		defer syncResults.AddRequestCost(WafIPSetManager)()
+		return remoteRegion.GetICloudWafIPSets()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudWafIPSets for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
-	result := localRegion.SyncWafIPSets(ctx, userCred, provider, ipSets)
+
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(WafIPSetManager)()
+		return localRegion.SyncWafIPSets(ctx, userCred, provider, ipSets)
+	}()
+
 	syncResults.Add(WafIPSetManager, result)
 	log.Infof("SyncWafIPSets for region %s result: %s", localRegion.Name, result.Result())
 	if result.IsError() {
@@ -1100,13 +1261,19 @@ func syncWafIPSets(ctx context.Context, userCred mcclient.TokenCredential, syncR
 }
 
 func syncWafRegexSets(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	rSets, err := remoteRegion.GetICloudWafRegexSets()
+	rSets, err := func() ([]cloudprovider.ICloudWafRegexSet, error) {
+		defer syncResults.AddRequestCost(WafRegexSetManager)()
+		return remoteRegion.GetICloudWafRegexSets()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudWafRegexSets for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
-	result := localRegion.SyncWafRegexSets(ctx, userCred, provider, rSets)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(WafRegexSetManager)()
+		return localRegion.SyncWafRegexSets(ctx, userCred, provider, rSets)
+	}()
 	syncResults.Add(WafRegexSetManager, result)
 	log.Infof("SyncWafRegexSets for region %s result: %s", localRegion.Name, result.Result())
 	if result.IsError() {
@@ -1116,14 +1283,20 @@ func syncWafRegexSets(ctx context.Context, userCred mcclient.TokenCredential, sy
 }
 
 func syncMongoDBs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	dbs, err := remoteRegion.GetICloudMongoDBs()
+	dbs, err := func() ([]cloudprovider.ICloudMongoDB, error) {
+		defer syncResults.AddRequestCost(MongoDBManager)()
+		return remoteRegion.GetICloudMongoDBs()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudMongoDBs for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
 
-	_, _, result := localRegion.SyncMongoDBs(ctx, userCred, provider, dbs)
+	_, _, result := func() ([]SMongoDB, []cloudprovider.ICloudMongoDB, compare.SyncResult) {
+		defer syncResults.AddSqlCost(MongoDBManager)()
+		return localRegion.SyncMongoDBs(ctx, userCred, provider, dbs)
+	}()
 	syncResults.Add(MongoDBManager, result)
 	msg := result.Result()
 	log.Infof("SyncMongoDBs for region %s result: %s", localRegion.Name, msg)
@@ -1135,14 +1308,20 @@ func syncMongoDBs(ctx context.Context, userCred mcclient.TokenCredential, syncRe
 }
 
 func syncElasticSearchs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	iEss, err := remoteRegion.GetIElasticSearchs()
+	iEss, err := func() ([]cloudprovider.ICloudElasticSearch, error) {
+		defer syncResults.AddRequestCost(ElasticSearchManager)()
+		return remoteRegion.GetIElasticSearchs()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIElasticSearchs for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
 
-	result := localRegion.SyncElasticSearchs(ctx, userCred, provider, iEss)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(ElasticSearchManager)()
+		return localRegion.SyncElasticSearchs(ctx, userCred, provider, iEss)
+	}()
 	syncResults.Add(ElasticSearchManager, result)
 	msg := result.Result()
 	log.Infof("SyncElasticSearchs for region %s result: %s", localRegion.Name, msg)
@@ -1153,14 +1332,20 @@ func syncElasticSearchs(ctx context.Context, userCred mcclient.TokenCredential,
 }
 
 func syncKafkas(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	iKafkas, err := remoteRegion.GetICloudKafkas()
+	iKafkas, err := func() ([]cloudprovider.ICloudKafka, error) {
+		defer syncResults.AddRequestCost(KafkaManager)()
+		return remoteRegion.GetICloudKafkas()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudKafkas for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
 
-	result := localRegion.SyncKafkas(ctx, userCred, provider, iKafkas)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(KafkaManager)()
+		return localRegion.SyncKafkas(ctx, userCred, provider, iKafkas)
+	}()
 	syncResults.Add(KafkaManager, result)
 	msg := result.Result()
 	log.Infof("SyncKafkas for region %s result: %s", localRegion.Name, msg)
@@ -1171,14 +1356,19 @@ func syncKafkas(ctx context.Context, userCred mcclient.TokenCredential, syncResu
 }
 
 func syncApps(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	log.Infof("try to syncApps")
-	iApps, err := remoteRegion.GetICloudApps()
+	iApps, err := func() ([]cloudprovider.ICloudApp, error) {
+		defer syncResults.AddRequestCost(AppManager)()
+		return remoteRegion.GetICloudApps()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudApps for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
-	result := localRegion.SyncApps(ctx, userCred, provider, iApps)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(AppManager)()
+		return localRegion.SyncApps(ctx, userCred, provider, iApps)
+	}()
 	syncResults.Add(AppManager, result)
 	msg := result.Result()
 	log.Infof("SyncApps for region %s result: %s", localRegion.Name, msg)
@@ -1189,14 +1379,20 @@ func syncApps(ctx context.Context, userCred mcclient.TokenCredential, syncResult
 }
 
 func syncWafInstances(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error {
-	wafIns, err := remoteRegion.GetICloudWafInstances()
+	wafIns, err := func() ([]cloudprovider.ICloudWafInstance, error) {
+		defer syncResults.AddRequestCost(WafInstanceManager)()
+		return remoteRegion.GetICloudWafInstances()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetICloudWafInstances for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return err
 	}
 
-	localWafs, remoteWafs, result := localRegion.SyncWafInstances(ctx, userCred, provider, wafIns)
+	localWafs, remoteWafs, result := func() ([]SWafInstance, []cloudprovider.ICloudWafInstance, compare.SyncResult) {
+		defer syncResults.AddSqlCost(WafInstanceManager)()
+		return localRegion.SyncWafInstances(ctx, userCred, provider, wafIns)
+	}()
 	syncResults.Add(WafInstanceManager, result)
 	msg := result.Result()
 	log.Infof("SyncWafInstances for region %s result: %s", localRegion.Name, msg)
@@ -1225,13 +1421,19 @@ func syncWafInstances(ctx context.Context, userCred mcclient.TokenCredential, sy
 }
 
 func syncWafRules(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localWaf *SWafInstance, remoteWafs cloudprovider.ICloudWafInstance) error {
-	rules, err := remoteWafs.GetRules()
+	rules, err := func() ([]cloudprovider.ICloudWafRule, error) {
+		defer syncResults.AddRequestCost(WafRuleManager)()
+		return remoteWafs.GetRules()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetRules for waf instance %s failed %s", localWaf.Name, err)
 		log.Errorf(msg)
 		return err
 	}
-	result := localWaf.SyncWafRules(ctx, userCred, rules)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(WafRuleManager)()
+		return localWaf.SyncWafRules(ctx, userCred, rules)
+	}()
 	syncResults.Add(WafRuleManager, result)
 	msg := result.Result()
 	log.Infof("SyncWafRules for waf %s result: %s", localWaf.Name, msg)
@@ -1242,14 +1444,20 @@ func syncWafRules(ctx context.Context, userCred mcclient.TokenCredential, syncRe
 }
 
 func syncRegionSnapshots(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	snapshots, err := remoteRegion.GetISnapshots()
+	snapshots, err := func() ([]cloudprovider.ICloudSnapshot, error) {
+		defer syncResults.AddRequestCost(SnapshotManager)()
+		return remoteRegion.GetISnapshots()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetISnapshots for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := SnapshotManager.SyncSnapshots(ctx, userCred, provider, localRegion, snapshots, provider.GetOwnerId())
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(SnapshotManager)()
+		return SnapshotManager.SyncSnapshots(ctx, userCred, provider, localRegion, snapshots, provider.GetOwnerId())
+	}()
 
 	syncResults.Add(SnapshotManager, result)
 
@@ -1262,14 +1470,19 @@ func syncRegionSnapshots(ctx context.Context, userCred mcclient.TokenCredential,
 }
 
 func syncRegionSnapshotPolicies(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	snapshotPolicies, err := remoteRegion.GetISnapshotPolicies()
+	snapshotPolicies, err := func() ([]cloudprovider.ICloudSnapshotPolicy, error) {
+		defer syncResults.AddRequestCost(SnapshotPolicyManager)()
+		return remoteRegion.GetISnapshotPolicies()
+	}()
 	if err != nil {
 		log.Errorf("GetISnapshotPolicies for region %s failed %s", remoteRegion.GetName(), err)
 		return
 	}
 
-	result := SnapshotPolicyManager.SyncSnapshotPolicies(
-		ctx, userCred, provider, localRegion, snapshotPolicies, provider.GetOwnerId())
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(SnapshotPolicyManager)()
+		return SnapshotPolicyManager.SyncSnapshotPolicies(ctx, userCred, provider, localRegion, snapshotPolicies, provider.GetOwnerId())
+	}()
 	syncResults.Add(SnapshotPolicyManager, result)
 	msg := result.Result()
 	log.Infof("SyncSnapshotPolicies for region %s result: %s", localRegion.Name, msg)
@@ -1279,14 +1492,20 @@ func syncRegionSnapshotPolicies(ctx context.Context, userCred mcclient.TokenCred
 }
 
 func syncRegionNetworkInterfaces(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	networkInterfaces, err := remoteRegion.GetINetworkInterfaces()
+	networkInterfaces, err := func() ([]cloudprovider.ICloudNetworkInterface, error) {
+		defer syncResults.AddRequestCost(NetworkInterfaceManager)()
+		return remoteRegion.GetINetworkInterfaces()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetINetworkInterfaces for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
-	localInterfaces, remoteInterfaces, result := NetworkInterfaceManager.SyncNetworkInterfaces(ctx, userCred, provider, localRegion, networkInterfaces)
 
+	localInterfaces, remoteInterfaces, result := func() ([]SNetworkInterface, []cloudprovider.ICloudNetworkInterface, compare.SyncResult) {
+		defer syncResults.AddSqlCost(NetworkInterfaceManager)()
+		return NetworkInterfaceManager.SyncNetworkInterfaces(ctx, userCred, provider, localRegion, networkInterfaces)
+	}()
 	syncResults.Add(NetworkInterfaceManager, result)
 
 	msg := result.Result()
@@ -1443,9 +1662,12 @@ func syncPublicCloudProviderInfo(
 		for i := range storageCachePairs {
 			// always sync private cloud cached images
 			if storageCachePairs[i].isNew || syncRange.DeepSync || !driver.GetFactory().IsPublicCloud() {
-				result := storageCachePairs[i].syncCloudImages(ctx, userCred)
+				result := func() compare.SyncResult {
+					defer syncResults.AddRequestCost(CachedimageManager)()
+					return storageCachePairs[i].syncCloudImages(ctx, userCred)
+				}()
 
-				syncResults.Add(StoragecachedimageManager, result)
+				syncResults.Add(CachedimageManager, result)
 
 				msg := result.Result()
 				log.Infof("syncCloudImages result: %s", msg)
@@ -1553,14 +1775,20 @@ func syncOnPremiseCloudProviderInfo(
 	var storageCachePairs []sStoragecacheSyncPair
 	if cloudprovider.IsSupportCompute(driver) {
 		storageCachePairs = syncOnPremiseCloudProviderStorage(ctx, userCred, syncResults, provider, iregion, driver, syncRange)
-		ihosts, err := iregion.GetIHosts()
+		ihosts, err := func() ([]cloudprovider.ICloudHost, error) {
+			defer syncResults.AddRequestCost(HostManager)()
+			return iregion.GetIHosts()
+		}()
 		if err != nil {
 			msg := fmt.Sprintf("GetIHosts for provider %s failed %s", provider.GetName(), err)
 			log.Errorf(msg)
 			return err
 		}
 
-		localHosts, remoteHosts, result := HostManager.SyncHosts(ctx, userCred, provider, nil, ihosts)
+		localHosts, remoteHosts, result := func() ([]SHost, []cloudprovider.ICloudHost, compare.SyncResult) {
+			defer syncResults.AddSqlCost(HostManager)()
+			return HostManager.SyncHosts(ctx, userCred, provider, nil, ihosts)
+		}()
 
 		syncResults.Add(HostManager, result)
 
@@ -1587,8 +1815,12 @@ func syncOnPremiseCloudProviderInfo(
 		for i := range storageCachePairs {
 			// alway sync on-premise cached images
 			// if storageCachePairs[i].isNew || syncRange.DeepSync {
-			result := storageCachePairs[i].syncCloudImages(ctx, userCred)
-			syncResults.Add(StoragecachedimageManager, result)
+			result := func() compare.SyncResult {
+				defer syncResults.AddRequestCost(CachedimageManager)()
+				return storageCachePairs[i].syncCloudImages(ctx, userCred)
+			}()
+
+			syncResults.Add(CachedimageManager, result)
 			msg := result.Result()
 			log.Infof("syncCloudImages for stroagecache %s result: %s", storageCachePairs[i].local.GetId(), msg)
 			// }
@@ -1603,20 +1835,27 @@ func syncOnPremiseHostWires(ctx context.Context, userCred mcclient.TokenCredenti
 	if provider.Provider != api.CLOUD_PROVIDER_VMWARE {
 		return
 	}
-	result := localHost.SyncEsxiHostWires(ctx, userCred, remoteHost)
-	if syncResults != nil {
-		syncResults.Add(HostManager, result)
-	}
+	func() {
+		defer func() {
+			if syncResults != nil {
+				syncResults.AddSqlCost(HostwireManager)()
+			}
+		}()
+		result := localHost.SyncEsxiHostWires(ctx, userCred, remoteHost)
+		if syncResults != nil {
+			syncResults.Add(HostwireManager, result)
+		}
 
-	msg := result.Result()
-	notes := fmt.Sprintf("SyncEsxiHostWires for host %s result: %s", localHost.Name, msg)
-	if result.IsError() {
-		log.Errorf(notes)
-		return
-	} else {
-		log.Infof(notes)
-	}
-	db.OpsLog.LogEvent(provider, db.ACT_SYNC_HOST_COMPLETE, msg, userCred)
+		msg := result.Result()
+		notes := fmt.Sprintf("SyncEsxiHostWires for host %s result: %s", localHost.Name, msg)
+		if result.IsError() {
+			log.Errorf(notes)
+			return
+		} else {
+			log.Infof(notes)
+		}
+		db.OpsLog.LogEvent(provider, db.ACT_SYNC_HOST_COMPLETE, msg, userCred)
+	}()
 }
 
 func syncHostNics(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, localHost *SHost, remoteHost cloudprovider.ICloudHost) {

pkg/compute/models/cloudsyncelasticcache.go

@@ -21,6 +21,7 @@ import (
 	"github.com/pkg/errors"
 
 	"yunion.io/x/log"
+	"yunion.io/x/pkg/util/compare"
 
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
@@ -29,14 +30,20 @@ import (
 )
 
 func syncElasticcaches(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	extCacheDBs, err := remoteRegion.GetIElasticcaches()
+	extCacheDBs, err := func() ([]cloudprovider.ICloudElasticcache, error) {
+		defer syncResults.AddRequestCost(ElasticcacheManager)()
+		return remoteRegion.GetIElasticcaches()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIElasticcaches for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	localInstances, remoteInstances, result := ElasticcacheManager.SyncElasticcaches(ctx, userCred, provider.GetOwnerId(), provider, localRegion, extCacheDBs)
+	localInstances, remoteInstances, result := func() ([]SElasticcache, []cloudprovider.ICloudElasticcache, compare.SyncResult) {
+		defer syncResults.AddSqlCost(ElasticcacheManager)()
+		return ElasticcacheManager.SyncElasticcaches(ctx, userCred, provider.GetOwnerId(), provider, localRegion, extCacheDBs)
+	}()
 
 	syncResults.Add(ElasticcacheManager, result)
 
@@ -61,43 +68,58 @@ func syncElasticcaches(ctx context.Context, userCred mcclient.TokenCredential, s
 }
 
 func syncElasticcacheParameters(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) {
-	parameters, err := remoteInstance.GetICloudElasticcacheParameters()
+	parameters, err := func() ([]cloudprovider.ICloudElasticcacheParameter, error) {
+		defer syncResults.AddRequestCost(ElasticcacheParameterManager)()
+		return remoteInstance.GetICloudElasticcacheParameters()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIElasticcacheParameters for dbinstance %s failed %s", remoteInstance.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := ElasticcacheParameterManager.SyncElasticcacheParameters(ctx, userCred, localInstance, parameters)
-	syncResults.Add(ElasticcacheParameterManager, result)
+	func() {
+		defer syncResults.AddSqlCost(ElasticcacheParameterManager)()
+		result := ElasticcacheParameterManager.SyncElasticcacheParameters(ctx, userCred, localInstance, parameters)
+		syncResults.Add(ElasticcacheParameterManager, result)
 
-	msg := result.Result()
-	log.Infof("SyncElasticcacheParameters for dbinstance %s result: %s", localInstance.Name, msg)
-	if result.IsError() {
-		return
-	}
+		msg := result.Result()
+		log.Infof("SyncElasticcacheParameters for dbinstance %s result: %s", localInstance.Name, msg)
+		if result.IsError() {
+			return
+		}
+	}()
 }
 
 func syncElasticcacheAccounts(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) {
-	accounts, err := remoteInstance.GetICloudElasticcacheAccounts()
+	accounts, err := func() ([]cloudprovider.ICloudElasticcacheAccount, error) {
+		defer syncResults.AddRequestCost(ElasticcacheAccountManager)()
+		return remoteInstance.GetICloudElasticcacheAccounts()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIElasticcacheAccounts for dbinstance %s failed %s", remoteInstance.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := ElasticcacheAccountManager.SyncElasticcacheAccounts(ctx, userCred, localInstance, accounts)
-	syncResults.Add(ElasticcacheAccountManager, result)
+	func() {
+		defer syncResults.AddSqlCost(ElasticcacheAccountManager)()
+		result := ElasticcacheAccountManager.SyncElasticcacheAccounts(ctx, userCred, localInstance, accounts)
+		syncResults.Add(ElasticcacheAccountManager, result)
 
-	msg := result.Result()
-	log.Infof("SyncElasticcacheAccounts for dbinstance %s result: %s", localInstance.Name, msg)
-	if result.IsError() {
-		return
-	}
+		msg := result.Result()
+		log.Infof("SyncElasticcacheAccounts for dbinstance %s result: %s", localInstance.Name, msg)
+		if result.IsError() {
+			return
+		}
+	}()
 }
 
 func syncElasticcacheAcls(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) {
-	acls, err := remoteInstance.GetICloudElasticcacheAcls()
+	acls, err := func() ([]cloudprovider.ICloudElasticcacheAcl, error) {
+		defer syncResults.AddRequestCost(ElasticcacheAclManager)()
+		return remoteInstance.GetICloudElasticcacheAcls()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIElasticcacheAcls for dbinstance %s failed %s", remoteInstance.GetName(), err)
 		if errors.Cause(err) == cloudprovider.ErrNotSupported {
@@ -108,36 +130,48 @@ func syncElasticcacheAcls(ctx context.Context, userCred mcclient.TokenCredential
 		return
 	}
 
-	result := ElasticcacheAclManager.SyncElasticcacheAcls(ctx, userCred, localInstance, acls)
-	syncResults.Add(ElasticcacheAclManager, result)
+	func() {
+		defer syncResults.AddSqlCost(ElasticcacheAclManager)()
+		result := ElasticcacheAclManager.SyncElasticcacheAcls(ctx, userCred, localInstance, acls)
+		syncResults.Add(ElasticcacheAclManager, result)
 
-	msg := result.Result()
-	log.Infof("SyncElasticcacheAcls for dbinstance %s result: %s", localInstance.Name, msg)
-	if result.IsError() {
-		return
-	}
+		msg := result.Result()
+		log.Infof("SyncElasticcacheAcls for dbinstance %s result: %s", localInstance.Name, msg)
+		if result.IsError() {
+			return
+		}
+	}()
 }
 
 func syncElasticcacheBackups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) {
-	backups, err := remoteInstance.GetICloudElasticcacheBackups()
+	backups, err := func() ([]cloudprovider.ICloudElasticcacheBackup, error) {
+		defer syncResults.AddRequestCost(ElasticcacheBackupManager)()
+		return remoteInstance.GetICloudElasticcacheBackups()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetIElasticcacheBackups for dbinstance %s failed %s", remoteInstance.GetName(), err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := ElasticcacheBackupManager.SyncElasticcacheBackups(ctx, userCred, localInstance, backups)
-	syncResults.Add(ElasticcacheBackupManager, result)
+	func() {
+		defer syncResults.AddSqlCost(ElasticcacheBackupManager)()
+		result := ElasticcacheBackupManager.SyncElasticcacheBackups(ctx, userCred, localInstance, backups)
+		syncResults.Add(ElasticcacheBackupManager, result)
 
-	msg := result.Result()
-	log.Infof("SyncElasticcacheBackups for dbinstance %s result: %s", localInstance.Name, msg)
-	if result.IsError() {
-		return
-	}
+		msg := result.Result()
+		log.Infof("SyncElasticcacheBackups for dbinstance %s result: %s", localInstance.Name, msg)
+		if result.IsError() {
+			return
+		}
+	}()
 }
 
 func syncElasticcacheSecgroups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) {
-	secgroupIds, err := remoteInstance.GetSecurityGroupIds()
+	secgroupIds, err := func() ([]string, error) {
+		defer syncResults.AddRequestCost(ElasticcachesecgroupManager)()
+		return remoteInstance.GetSecurityGroupIds()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("Elasticcache.GetSecurityGroupIds for dbinstance %s failed %s", remoteInstance.GetName(), err)
 		if errors.Cause(err) == cloudprovider.ErrNotSupported {
@@ -148,12 +182,15 @@ func syncElasticcacheSecgroups(ctx context.Context, userCred mcclient.TokenCrede
 		return
 	}
 
-	result := localInstance.SyncElasticcacheSecgroups(ctx, userCred, secgroupIds)
-	syncResults.Add(ElasticcachesecgroupManager, result)
+	func() {
+		defer syncResults.AddSqlCost(ElasticcachesecgroupManager)()
+		result := localInstance.SyncElasticcacheSecgroups(ctx, userCred, secgroupIds)
+		syncResults.Add(ElasticcachesecgroupManager, result)
 
-	msg := result.Result()
-	log.Infof("SyncElasticcacheSecgroups for dbinstance %s result: %s", localInstance.Name, msg)
-	if result.IsError() {
-		return
-	}
+		msg := result.Result()
+		log.Infof("SyncElasticcacheSecgroups for dbinstance %s result: %s", localInstance.Name, msg)
+		if result.IsError() {
+			return
+		}
+	}()
 }

pkg/compute/models/cloudsyncelb.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 
 	"yunion.io/x/log"
+	"yunion.io/x/pkg/util/compare"
 
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
@@ -27,13 +28,19 @@ import (
 )
 
 func syncRegionLoadbalancerCertificates(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	certificates, err := remoteRegion.GetILoadBalancerCertificates()
+	certificates, err := func() ([]cloudprovider.ICloudLoadbalancerCertificate, error) {
+		defer syncResults.AddRequestCost(LoadbalancerCertificateManager)()
+		return remoteRegion.GetILoadBalancerCertificates()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetILoadBalancerCertificates for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorln(msg)
 		return
 	}
-	result := CachedLoadbalancerCertificateManager.SyncLoadbalancerCertificates(ctx, userCred, provider, localRegion, certificates, syncRange)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(LoadbalancerCertificateManager)()
+		return CachedLoadbalancerCertificateManager.SyncLoadbalancerCertificates(ctx, userCred, provider, localRegion, certificates, syncRange)
+	}()
 
 	syncResults.Add(CachedLoadbalancerCertificateManager, result)
 
@@ -45,13 +52,19 @@ func syncRegionLoadbalancerCertificates(ctx context.Context, userCred mcclient.T
 }
 
 func syncRegionLoadbalancerAcls(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	acls, err := remoteRegion.GetILoadBalancerAcls()
+	acls, err := func() ([]cloudprovider.ICloudLoadbalancerAcl, error) {
+		defer syncResults.AddRequestCost(LoadbalancerAclManager)()
+		return remoteRegion.GetILoadBalancerAcls()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetILoadBalancerAcls for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorln(msg)
 		return
 	}
-	result := CachedLoadbalancerAclManager.SyncLoadbalancerAcls(ctx, userCred, provider, localRegion, acls, syncRange)
+	result := func() compare.SyncResult {
+		defer syncResults.AddSqlCost(LoadbalancerAclManager)()
+		return CachedLoadbalancerAclManager.SyncLoadbalancerAcls(ctx, userCred, provider, localRegion, acls, syncRange)
+	}()
 
 	syncResults.Add(CachedLoadbalancerAclManager, result)
 
@@ -63,42 +76,49 @@ func syncRegionLoadbalancerAcls(ctx context.Context, userCred mcclient.TokenCred
 }
 
 func syncRegionLoadbalancers(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) {
-	lbs, err := remoteRegion.GetILoadBalancers()
+	lbs, err := func() ([]cloudprovider.ICloudLoadbalancer, error) {
+		defer syncResults.AddRequestCost(LoadbalancerManager)()
+		return remoteRegion.GetILoadBalancers()
+	}()
 	if err != nil {
 		msg := fmt.Sprintf("GetILoadBalancers for region %s failed %s", remoteRegion.GetName(), err)
 		log.Errorln(msg)
 		return
 	}
-	localLbs, remoteLbs, result := LoadbalancerManager.SyncLoadbalancers(ctx, userCred, provider, localRegion, lbs, syncRange)
+	func() {
+		defer syncResults.AddSqlCost(LoadbalancerManager)()
 
-	syncResults.Add(LoadbalancerManager, result)
+		localLbs, remoteLbs, result := LoadbalancerManager.SyncLoadbalancers(ctx, userCred, provider, localRegion, lbs, syncRange)
 
-	msg := result.Result()
-	log.Infof("SyncLoadbalancers for region %s result: %s", localRegion.Name, msg)
-	if result.IsError() {
-		return
-	}
-	db.OpsLog.LogEvent(provider, db.ACT_SYNC_LB_COMPLETE, msg, userCred)
-	// 同步未关联负载均衡的后端服务器组
-	regionDriver := localRegion.GetDriver()
-	if regionDriver == nil {
-		msg := fmt.Sprintf("GetRegionDriver %s failed", localRegion.GetName())
-		log.Errorln(msg)
-		return
-	}
+		syncResults.Add(LoadbalancerManager, result)
 
-	regionDriver.RequestPullRegionLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, localRegion, remoteRegion, syncRange)
+		msg := result.Result()
+		log.Infof("SyncLoadbalancers for region %s result: %s", localRegion.Name, msg)
+		if result.IsError() {
+			return
+		}
+		db.OpsLog.LogEvent(provider, db.ACT_SYNC_LB_COMPLETE, msg, userCred)
+		// 同步未关联负载均衡的后端服务器组
+		regionDriver := localRegion.GetDriver()
+		if regionDriver == nil {
+			msg := fmt.Sprintf("GetRegionDriver %s failed", localRegion.GetName())
+			log.Errorln(msg)
+			return
+		}
 
-	for i := 0; i < len(localLbs); i++ {
-		func() {
-			lockman.LockObject(ctx, &localLbs[i])
-			defer lockman.ReleaseObject(ctx, &localLbs[i])
+		regionDriver.RequestPullRegionLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, localRegion, remoteRegion, syncRange)
 
-			syncLoadbalancerEip(ctx, userCred, provider, &localLbs[i], remoteLbs[i])
-			regionDriver.RequestPullLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange)
-			syncLoadbalancerListeners(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange)
-		}()
-	}
+		for i := 0; i < len(localLbs); i++ {
+			func() {
+				lockman.LockObject(ctx, &localLbs[i])
+				defer lockman.ReleaseObject(ctx, &localLbs[i])
+
+				syncLoadbalancerEip(ctx, userCred, provider, &localLbs[i], remoteLbs[i])
+				regionDriver.RequestPullLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange)
+				syncLoadbalancerListeners(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange)
+			}()
+		}
+	}()
 }
 
 func syncLoadbalancerEip(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, localLb *SLoadbalancer, remoteLb cloudprovider.ICloudLoadbalancer) {