diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index ebaf1041c9..6bb23ba8bd 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -319,9 +319,15 @@ int32_t tsMaxTsmaNum = 3;
 int32_t tsMaxTsmaCalcDelay = 600;
 int64_t tsmaDataDeleteMark = 1000 * 60 * 60 * 24;  // in ms, default to 1d
 
+#define TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, pName) \
+  if ((pItem = cfgGetItem(pCfg, pName)) == NULL) {  \
+    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);           \
+  }
+
 #ifndef _STORAGE
 int32_t taosSetTfsCfg(SConfig *pCfg) {
-  SConfigItem *pItem = cfgGetItem(pCfg, "dataDir");
+  SConfigItem *pItem = NULL;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dataDir");
   (void)memset(tsDataDir, 0, PATH_MAX);
 
   int32_t size = taosArrayGetSize(pItem->array);
@@ -343,7 +349,10 @@ int32_t taosSetTfsCfg(SConfig *pCfg);
 #endif
 
 int32_t taosSetS3Cfg(SConfig *pCfg) {
-  tstrncpy(tsS3AccessKey, cfgGetItem(pCfg, "s3Accesskey")->str, TSDB_FQDN_LEN);
+  SConfigItem *pItem = NULL;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "s3Accesskey");
+  tstrncpy(tsS3AccessKey, pItem->str, TSDB_FQDN_LEN);
   if (tsS3AccessKey[0] == '<') {
     TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
@@ -355,8 +364,10 @@ int32_t taosSetS3Cfg(SConfig *pCfg) {
   *colon = '\0';
   tstrncpy(tsS3AccessKeyId, tsS3AccessKey, TSDB_FQDN_LEN);
   tstrncpy(tsS3AccessKeySecret, colon + 1, TSDB_FQDN_LEN);
-  tstrncpy(tsS3Endpoint, cfgGetItem(pCfg, "s3Endpoint")->str, TSDB_FQDN_LEN);
-  tstrncpy(tsS3BucketName, cfgGetItem(pCfg, "s3BucketName")->str, TSDB_FQDN_LEN);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "s3Endpoint");
+  tstrncpy(tsS3Endpoint, pItem->str, TSDB_FQDN_LEN);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "s3BucketName");
+  tstrncpy(tsS3BucketName, pItem->str, TSDB_FQDN_LEN);
   char *proto = strstr(tsS3Endpoint, "https://");
   if (!proto) {
     tsS3Https = false;
@@ -785,7 +796,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
   int32_t      numOfCores;
   int64_t      totalMemoryKB;
 
-  pItem = cfgGetItem(tsCfg, "numOfCores");
+  pItem = cfgGetItem(pCfg, "numOfCores");
   if (pItem == NULL) {
     TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
   } else {
@@ -793,7 +804,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     numOfCores = pItem->fval;
   }
 
-  pItem = cfgGetItem(tsCfg, "supportVnodes");
+  pItem = cfgGetItem(pCfg, "supportVnodes");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfSupportVnodes = numOfCores * 2 + 5;
     tsNumOfSupportVnodes = TMAX(tsNumOfSupportVnodes, 2);
@@ -801,7 +812,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfRpcThreads");
+  pItem = cfgGetItem(pCfg, "numOfRpcThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfRpcThreads = numOfCores / 2;
     tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 2, TSDB_MAX_RPC_THREADS);
@@ -809,21 +820,21 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfRpcSessions");
+  pItem = cfgGetItem(pCfg, "numOfRpcSessions");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfRpcSessions = TRANGE(tsNumOfRpcSessions, 100, 10000);
     pItem->i32 = tsNumOfRpcSessions;
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "timeToGetAvailableConn");
+  pItem = cfgGetItem(pCfg, "timeToGetAvailableConn");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsTimeToGetAvailableConn = TRANGE(tsTimeToGetAvailableConn, 20, 1000000);
     pItem->i32 = tsTimeToGetAvailableConn;
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfCommitThreads");
+  pItem = cfgGetItem(pCfg, "numOfCommitThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfCommitThreads = numOfCores / 2;
     tsNumOfCommitThreads = TRANGE(tsNumOfCommitThreads, 2, 4);
@@ -831,7 +842,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfMnodeReadThreads");
+  pItem = cfgGetItem(pCfg, "numOfMnodeReadThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfMnodeReadThreads = numOfCores / 8;
     tsNumOfMnodeReadThreads = TRANGE(tsNumOfMnodeReadThreads, 1, 4);
@@ -839,7 +850,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfVnodeQueryThreads");
+  pItem = cfgGetItem(pCfg, "numOfVnodeQueryThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfVnodeQueryThreads = numOfCores * 2;
     tsNumOfVnodeQueryThreads = TMAX(tsNumOfVnodeQueryThreads, 16);
@@ -847,13 +858,13 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "ratioOfVnodeStreamThreads");
+  pItem = cfgGetItem(pCfg, "ratioOfVnodeStreamThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     pItem->fval = tsRatioOfVnodeStreamThreads;
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfVnodeFetchThreads");
+  pItem = cfgGetItem(pCfg, "numOfVnodeFetchThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfVnodeFetchThreads = numOfCores / 4;
     tsNumOfVnodeFetchThreads = TMAX(tsNumOfVnodeFetchThreads, 4);
@@ -861,7 +872,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfVnodeRsmaThreads");
+  pItem = cfgGetItem(pCfg, "numOfVnodeRsmaThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfVnodeRsmaThreads = numOfCores;
     tsNumOfVnodeRsmaThreads = TMAX(tsNumOfVnodeRsmaThreads, 4);
@@ -869,7 +880,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfQnodeQueryThreads");
+  pItem = cfgGetItem(pCfg, "numOfQnodeQueryThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfQnodeQueryThreads = numOfCores * 2;
     tsNumOfQnodeQueryThreads = TMAX(tsNumOfQnodeQueryThreads, 16);
@@ -877,17 +888,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  /*
-    pItem = cfgGetItem(tsCfg, "numOfQnodeFetchThreads");
-    if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
-      tsNumOfQnodeFetchThreads = numOfCores / 2;
-      tsNumOfQnodeFetchThreads = TMAX(tsNumOfQnodeFetchThreads, 4);
-      pItem->i32 = tsNumOfQnodeFetchThreads;
-      pItem->stype = stype;
-    }
-  */
-
-  pItem = cfgGetItem(tsCfg, "numOfSnodeSharedThreads");
+  pItem = cfgGetItem(pCfg, "numOfSnodeSharedThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfSnodeStreamThreads = numOfCores / 4;
     tsNumOfSnodeStreamThreads = TRANGE(tsNumOfSnodeStreamThreads, 2, 4);
@@ -895,7 +896,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "numOfSnodeUniqueThreads");
+  pItem = cfgGetItem(pCfg, "numOfSnodeUniqueThreads");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsNumOfSnodeWriteThreads = numOfCores / 4;
     tsNumOfSnodeWriteThreads = TRANGE(tsNumOfSnodeWriteThreads, 2, 4);
@@ -903,7 +904,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     pItem->stype = stype;
   }
 
-  pItem = cfgGetItem(tsCfg, "totalMemoryKB");
+  pItem = cfgGetItem(pCfg, "totalMemoryKB");
   if (pItem == NULL) {
     TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
   } else {
@@ -911,7 +912,7 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
     totalMemoryKB = pItem->i64;
   }
 
-  pItem = cfgGetItem(tsCfg, "rpcQueueMemoryAllowed");
+  pItem = cfgGetItem(pCfg, "rpcQueueMemoryAllowed");
   if (pItem != NULL && pItem->stype == CFG_STYPE_DEFAULT) {
     tsRpcQueueMemoryAllowed = totalMemoryKB * 1024 * 0.1;
     tsRpcQueueMemoryAllowed = TRANGE(tsRpcQueueMemoryAllowed, TSDB_MAX_MSG_SIZE * 10LL, TSDB_MAX_MSG_SIZE * 10000LL);
@@ -922,39 +923,97 @@ static int32_t taosUpdateServerCfg(SConfig *pCfg) {
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-static void taosSetClientLogCfg(SConfig *pCfg) {
-  SConfigItem *pItem = cfgGetItem(pCfg, "logDir");
-  tstrncpy(tsLogDir, cfgGetItem(pCfg, "logDir")->str, PATH_MAX);
-  taosExpandDir(tsLogDir, tsLogDir, PATH_MAX);
-  tsLogSpace.reserved = (int64_t)(((double)cfgGetItem(pCfg, "minimalLogDirGB")->fval) * 1024 * 1024 * 1024);
-  tsNumOfLogLines = cfgGetItem(pCfg, "numOfLogLines")->i32;
-  tsAsyncLog = cfgGetItem(pCfg, "asyncLog")->bval;
-  tsLogKeepDays = cfgGetItem(pCfg, "logKeepDays")->i32;
-  tmrDebugFlag = cfgGetItem(pCfg, "tmrDebugFlag")->i32;
-  uDebugFlag = cfgGetItem(pCfg, "uDebugFlag")->i32;
-  jniDebugFlag = cfgGetItem(pCfg, "jniDebugFlag")->i32;
-  rpcDebugFlag = cfgGetItem(pCfg, "rpcDebugFlag")->i32;
-  qDebugFlag = cfgGetItem(pCfg, "qDebugFlag")->i32;
-  cDebugFlag = cfgGetItem(pCfg, "cDebugFlag")->i32;
-  simDebugFlag = cfgGetItem(pCfg, "simDebugFlag")->i32;
+static int32_t taosSetClientLogCfg(SConfig *pCfg) {
+  SConfigItem *pItem = NULL;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "logDir");
+  tstrncpy(tsLogDir, pItem->str, PATH_MAX);
+  TAOS_CHECK_RETURN(taosExpandDir(tsLogDir, tsLogDir, PATH_MAX));
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalLogDirGB");
+  tsLogSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfLogLines");
+  tsNumOfLogLines = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "asyncLog");
+  tsAsyncLog = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "logKeepDays");
+  tsLogKeepDays = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmrDebugFlag");
+  tmrDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "uDebugFlag");
+  uDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "jniDebugFlag");
+  jniDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcDebugFlag");
+  rpcDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "qDebugFlag");
+  qDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "cDebugFlag");
+  cDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "simDebugFlag");
+  simDebugFlag = pItem->i32;
+
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-static void taosSetServerLogCfg(SConfig *pCfg) {
-  dDebugFlag = cfgGetItem(pCfg, "dDebugFlag")->i32;
-  vDebugFlag = cfgGetItem(pCfg, "vDebugFlag")->i32;
-  mDebugFlag = cfgGetItem(pCfg, "mDebugFlag")->i32;
-  wDebugFlag = cfgGetItem(pCfg, "wDebugFlag")->i32;
-  sDebugFlag = cfgGetItem(pCfg, "sDebugFlag")->i32;
-  tsdbDebugFlag = cfgGetItem(pCfg, "tsdbDebugFlag")->i32;
-  tqDebugFlag = cfgGetItem(pCfg, "tqDebugFlag")->i32;
-  fsDebugFlag = cfgGetItem(pCfg, "fsDebugFlag")->i32;
-  udfDebugFlag = cfgGetItem(pCfg, "udfDebugFlag")->i32;
-  smaDebugFlag = cfgGetItem(pCfg, "smaDebugFlag")->i32;
-  idxDebugFlag = cfgGetItem(pCfg, "idxDebugFlag")->i32;
-  tdbDebugFlag = cfgGetItem(pCfg, "tdbDebugFlag")->i32;
-  metaDebugFlag = cfgGetItem(pCfg, "metaDebugFlag")->i32;
-  stDebugFlag = cfgGetItem(pCfg, "stDebugFlag")->i32;
-  sndDebugFlag = cfgGetItem(pCfg, "sndDebugFlag")->i32;
+static int32_t taosSetServerLogCfg(SConfig *pCfg) {
+  SConfigItem *pItem = NULL;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dDebugFlag");
+  dDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "vDebugFlag");
+  vDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mDebugFlag");
+  mDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "wDebugFlag");
+  wDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sDebugFlag");
+  sDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsdbDebugFlag");
+  tsdbDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tqDebugFlag");
+  tqDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fsDebugFlag");
+  fsDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfDebugFlag");
+  udfDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smaDebugFlag");
+  smaDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "idxDebugFlag");
+  idxDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tdbDebugFlag");
+  tdbDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaDebugFlag");
+  metaDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "stDebugFlag");
+  stDebugFlag = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "sndDebugFlag");
+  sndDebugFlag = pItem->i32;
+
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t taosSetSlowLogScope(char *pScopeStr, int32_t *pScope) {
@@ -1008,105 +1067,159 @@ int32_t taosSetSlowLogScope(char *pScopeStr, int32_t *pScope) {
 
 // for common configs
 static int32_t taosSetClientCfg(SConfig *pCfg) {
-  tstrncpy(tsLocalFqdn, cfgGetItem(pCfg, "fqdn")->str, TSDB_FQDN_LEN);
-  tsServerPort = (uint16_t)cfgGetItem(pCfg, "serverPort")->i32;
+  SConfigItem *pItem = NULL;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fqdn");
+  tstrncpy(tsLocalFqdn, pItem->str, TSDB_FQDN_LEN);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "serverPort");
+  tsServerPort = (uint16_t)pItem->i32;
   (void)snprintf(tsLocalEp, sizeof(tsLocalEp), "%s:%u", tsLocalFqdn, tsServerPort);
 
   char defaultFirstEp[TSDB_EP_LEN] = {0};
   (void)snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);
 
-  SConfigItem *pFirstEpItem = cfgGetItem(pCfg, "firstEp");
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "firstEp");
   SEp          firstEp = {0};
-  TAOS_CHECK_RETURN(taosGetFqdnPortFromEp(strlen(pFirstEpItem->str) == 0 ? defaultFirstEp : pFirstEpItem->str, &firstEp));
+  TAOS_CHECK_RETURN(taosGetFqdnPortFromEp(strlen(pItem->str) == 0 ? defaultFirstEp : pItem->str, &firstEp));
   (void)snprintf(tsFirst, sizeof(tsFirst), "%s:%u", firstEp.fqdn, firstEp.port);
-  TAOS_CHECK_RETURN(cfgSetItem(pCfg, "firstEp", tsFirst, pFirstEpItem->stype, true));
+  TAOS_CHECK_RETURN(cfgSetItem(pCfg, "firstEp", tsFirst, pItem->stype, true));
 
-  SConfigItem *pSecondpItem = cfgGetItem(pCfg, "secondEp");
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "secondEp");
   SEp          secondEp = {0};
-  TAOS_CHECK_RETURN(taosGetFqdnPortFromEp(strlen(pSecondpItem->str) == 0 ? defaultFirstEp : pSecondpItem->str, &secondEp));
+  TAOS_CHECK_RETURN(taosGetFqdnPortFromEp(strlen(pItem->str) == 0 ? defaultFirstEp : pItem->str, &secondEp));
   (void)snprintf(tsSecond, sizeof(tsSecond), "%s:%u", secondEp.fqdn, secondEp.port);
-  TAOS_CHECK_RETURN(cfgSetItem(pCfg, "secondEp", tsSecond, pSecondpItem->stype, true));
+  TAOS_CHECK_RETURN(cfgSetItem(pCfg, "secondEp", tsSecond, pItem->stype, true));
 
-  tstrncpy(tsTempDir, cfgGetItem(pCfg, "tempDir")->str, PATH_MAX);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tempDir");
+  tstrncpy(tsTempDir, pItem->str, PATH_MAX);
   TAOS_CHECK_RETURN(taosExpandDir(tsTempDir, tsTempDir, PATH_MAX));
-  tsTempSpace.reserved = (int64_t)(((double)cfgGetItem(pCfg, "minimalTmpDirGB")->fval) * 1024 * 1024 * 1024);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalTmpDirGB");
+  tsTempSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);
   if (taosMulMkDir(tsTempDir) != 0) {
     int32_t code = TAOS_SYSTEM_ERROR(errno);
     uError("failed to create tempDir:%s since %s", tsTempDir, tstrerror(code));
     TAOS_RETURN(code);
   }
 
-  tstrncpy(tsSmlAutoChildTableNameDelimiter, cfgGetItem(pCfg, "smlAutoChildTableNameDelimiter")->str,
-           TSDB_TABLE_NAME_LEN);
-  tstrncpy(tsSmlChildTableName, cfgGetItem(pCfg, "smlChildTableName")->str, TSDB_TABLE_NAME_LEN);
-  tstrncpy(tsSmlTagName, cfgGetItem(pCfg, "smlTagName")->str, TSDB_COL_NAME_LEN);
-  tstrncpy(tsSmlTsDefaultName, cfgGetItem(pCfg, "smlTsDefaultName")->str, TSDB_COL_NAME_LEN);
-  tsSmlDot2Underline = cfgGetItem(pCfg, "smlDot2Underline")->bval;
-  //  tsSmlDataFormat = cfgGetItem(pCfg, "smlDataFormat")->bval;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlAutoChildTableNameDelimiter");
+  tstrncpy(tsSmlAutoChildTableNameDelimiter, pItem->str, TSDB_TABLE_NAME_LEN);
 
-  //  tsSmlBatchSize = cfgGetItem(pCfg, "smlBatchSize")->i32;
-  tsMaxInsertBatchRows = cfgGetItem(pCfg, "maxInsertBatchRows")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlChildTableName");
+  tstrncpy(tsSmlChildTableName, pItem->str, TSDB_TABLE_NAME_LEN);
 
-  tsShellActivityTimer = cfgGetItem(pCfg, "shellActivityTimer")->i32;
-  tsCompressMsgSize = cfgGetItem(pCfg, "compressMsgSize")->i32;
-  tsNumOfTaskQueueThreads = cfgGetItem(pCfg, "numOfTaskQueueThreads")->i32;
-  tsQueryPolicy = cfgGetItem(pCfg, "queryPolicy")->i32;
-  tsEnableQueryHb = cfgGetItem(pCfg, "enableQueryHb")->bval;
-  tsEnableScience = cfgGetItem(pCfg, "enableScience")->bval;
-  tsQuerySmaOptimize = cfgGetItem(pCfg, "querySmaOptimize")->i32;
-  tsQueryPlannerTrace = cfgGetItem(pCfg, "queryPlannerTrace")->bval;
-  tsQueryNodeChunkSize = cfgGetItem(pCfg, "queryNodeChunkSize")->i32;
-  tsQueryUseNodeAllocator = cfgGetItem(pCfg, "queryUseNodeAllocator")->bval;
-  tsKeepColumnName = cfgGetItem(pCfg, "keepColumnName")->bval;
-  tsUseAdapter = cfgGetItem(pCfg, "useAdapter")->bval;
-  tsEnableCrashReport = cfgGetItem(pCfg, "crashReporting")->bval;
-  tsQueryMaxConcurrentTables = cfgGetItem(pCfg, "queryMaxConcurrentTables")->i64;
-  tsMetaCacheMaxSize = cfgGetItem(pCfg, "metaCacheMaxSize")->i32;
-  tsCountAlwaysReturnValue = cfgGetItem(pCfg, "countAlwaysReturnValue")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlTagName");
+  tstrncpy(tsSmlTagName, pItem->str, TSDB_COL_NAME_LEN);
 
-  tsMaxRetryWaitTime = cfgGetItem(pCfg, "maxRetryWaitTime")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlTsDefaultName");
+  tstrncpy(tsSmlTsDefaultName, pItem->str, TSDB_COL_NAME_LEN);
 
-  tsNumOfRpcThreads = cfgGetItem(pCfg, "numOfRpcThreads")->i32;
-  tsNumOfRpcSessions = cfgGetItem(pCfg, "numOfRpcSessions")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "smlDot2Underline");
+  tsSmlDot2Underline = pItem->bval;
 
-  tsTimeToGetAvailableConn = cfgGetItem(pCfg, "timeToGetAvailableConn")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxInsertBatchRows");
+  tsMaxInsertBatchRows = pItem->i32;
 
-  tsKeepAliveIdle = cfgGetItem(pCfg, "keepAliveIdle")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "shellActivityTimer");
+  tsShellActivityTimer = pItem->i32;
 
-  tsExperimental = cfgGetItem(pCfg, "experimental")->bval;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compressMsgSize");
+  tsCompressMsgSize = pItem->i32;
 
-  tsMultiResultFunctionStarReturnTags = cfgGetItem(pCfg, "multiResultFunctionStarReturnTags")->bval;
-  tsMaxTsmaCalcDelay = cfgGetItem(pCfg, "maxTsmaCalcDelay")->i32;
-  tsmaDataDeleteMark = cfgGetItem(pCfg, "tsmaDataDeleteMark")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfTaskQueueThreads");
+  tsNumOfTaskQueueThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryPolicy");
+  tsQueryPolicy = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableQueryHb");
+  tsEnableQueryHb = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableScience");
+  tsEnableScience = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "querySmaOptimize");
+  tsQuerySmaOptimize = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryPlannerTrace");
+  tsQueryPlannerTrace = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryNodeChunkSize");
+  tsQueryNodeChunkSize = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryUseNodeAllocator");
+  tsQueryUseNodeAllocator = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "keepColumnName");
+  tsKeepColumnName = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "useAdapter");
+  tsUseAdapter = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "crashReporting");
+  tsEnableCrashReport = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryMaxConcurrentTables");
+  tsQueryMaxConcurrentTables = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaCacheMaxSize");
+  tsMetaCacheMaxSize = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "countAlwaysReturnValue");
+  tsCountAlwaysReturnValue = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxRetryWaitTime");
+  tsMaxRetryWaitTime = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcThreads");
+  tsNumOfRpcThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcSessions");
+  tsNumOfRpcSessions = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");
+  tsTimeToGetAvailableConn = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "keepAliveIdle");
+  tsKeepAliveIdle = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");
+  tsExperimental = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "multiResultFunctionStarReturnTags");
+  tsMultiResultFunctionStarReturnTags = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxTsmaCalcDelay");
+  tsMaxTsmaCalcDelay = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tsmaDataDeleteMark");
+  tsmaDataDeleteMark = pItem->i32;
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t taosSetSystemCfg(SConfig *pCfg) {
-  SConfigItem *pItem = cfgGetItem(pCfg, "timezone");
-  if (NULL == pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
+  SConfigItem *pItem = NULL;
 
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timezone");
   TAOS_CHECK_RETURN(osSetTimezone(pItem->str));
   uDebug("timezone format changed from %s to %s", pItem->str, tsTimezoneStr);
   TAOS_CHECK_RETURN(cfgSetItem(pCfg, "timezone", tsTimezoneStr, pItem->stype, true));
 
-  pItem = cfgGetItem(pCfg, "locale");
-  if (NULL == pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "locale");
   const char *locale = pItem->str;
 
-  pItem = cfgGetItem(pCfg, "charset");
-  if (NULL == pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "charset");
   const char *charset = pItem->str;
 
-  taosSetSystemLocale(locale, charset);
+  TAOS_CHECK_RETURN(taosSetSystemLocale(locale, charset));
   osSetSystemLocale(locale, charset);
 
-  pItem = cfgGetItem(pCfg, "enableCoreFile");
-  if (NULL == pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableCoreFile");
   bool enableCore = pItem->bval;
   taosSetCoreDump(enableCore);
 
-  pItem = cfgGetItem(pCfg, "assert");
-  if (NULL == pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "assert");
   tsAssert = pItem->bval;
 
   // todo
@@ -1117,136 +1230,312 @@ static int32_t taosSetSystemCfg(SConfig *pCfg) {
 
 // for server configs
 static int32_t taosSetServerCfg(SConfig *pCfg) {
-  tsDataSpace.reserved = (int64_t)(((double)cfgGetItem(pCfg, "minimalDataDirGB")->fval) * 1024 * 1024 * 1024);
-  tsNumOfSupportVnodes = cfgGetItem(pCfg, "supportVnodes")->i32;
-  tsMaxShellConns = cfgGetItem(pCfg, "maxShellConns")->i32;
-  tsStatusInterval = cfgGetItem(pCfg, "statusInterval")->i32;
-  tsMinSlidingTime = cfgGetItem(pCfg, "minSlidingTime")->i32;
-  tsMinIntervalTime = cfgGetItem(pCfg, "minIntervalTime")->i32;
-  tsQueryBufferSize = cfgGetItem(pCfg, "queryBufferSize")->i32;
-  tstrncpy(tsEncryptAlgorithm, cfgGetItem(pCfg, "encryptAlgorithm")->str, 16);
-  tstrncpy(tsEncryptScope, cfgGetItem(pCfg, "encryptScope")->str, 100);
-  // tstrncpy(tsAuthCode, cfgGetItem(pCfg, "authCode")->str, 100);
+  SConfigItem *pItem = NULL;
 
-  tsNumOfRpcThreads = cfgGetItem(pCfg, "numOfRpcThreads")->i32;
-  tsNumOfRpcSessions = cfgGetItem(pCfg, "numOfRpcSessions")->i32;
-  tsTimeToGetAvailableConn = cfgGetItem(pCfg, "timeToGetAvailableConn")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minimalDataDirGB");
+  tsDataSpace.reserved = (int64_t)(((double)pItem->fval) * 1024 * 1024 * 1024);
 
-  tsNumOfCommitThreads = cfgGetItem(pCfg, "numOfCommitThreads")->i32;
-  tsRetentionSpeedLimitMB = cfgGetItem(pCfg, "retentionSpeedLimitMB")->i32;
-  tsNumOfMnodeReadThreads = cfgGetItem(pCfg, "numOfMnodeReadThreads")->i32;
-  tsNumOfVnodeQueryThreads = cfgGetItem(pCfg, "numOfVnodeQueryThreads")->i32;
-  tsRatioOfVnodeStreamThreads = cfgGetItem(pCfg, "ratioOfVnodeStreamThreads")->fval;
-  tsNumOfVnodeFetchThreads = cfgGetItem(pCfg, "numOfVnodeFetchThreads")->i32;
-  tsNumOfVnodeRsmaThreads = cfgGetItem(pCfg, "numOfVnodeRsmaThreads")->i32;
-  tsNumOfQnodeQueryThreads = cfgGetItem(pCfg, "numOfQnodeQueryThreads")->i32;
-  //  tsNumOfQnodeFetchThreads = cfgGetItem(pCfg, "numOfQnodeFetchTereads")->i32;
-  tsNumOfSnodeStreamThreads = cfgGetItem(pCfg, "numOfSnodeSharedThreads")->i32;
-  tsNumOfSnodeWriteThreads = cfgGetItem(pCfg, "numOfSnodeUniqueThreads")->i32;
-  tsRpcQueueMemoryAllowed = cfgGetItem(pCfg, "rpcQueueMemoryAllowed")->i64;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "supportVnodes");
+  tsNumOfSupportVnodes = pItem->i32;
 
-  tsSIMDEnable = (bool)cfgGetItem(pCfg, "simdEnable")->bval;
-  tsTagFilterCache = (bool)cfgGetItem(pCfg, "tagFilterCache")->bval;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxShellConns");
+  tsMaxShellConns = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "statusInterval");
+  tsStatusInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minSlidingTime");
+  tsMinSlidingTime = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minIntervalTime");
+  tsMinIntervalTime = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryBufferSize");
+  tsQueryBufferSize = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptAlgorithm");
+  tstrncpy(tsEncryptAlgorithm, pItem->str, 16);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "encryptScope");
+  tstrncpy(tsEncryptScope, pItem->str, 100);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcThreads");
+  tsNumOfRpcThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfRpcSessions");
+  tsNumOfRpcSessions = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeToGetAvailableConn");
+  tsTimeToGetAvailableConn = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfCommitThreads");
+  tsNumOfCommitThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "retentionSpeedLimitMB");
+  tsRetentionSpeedLimitMB = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfMnodeReadThreads");
+  tsNumOfMnodeReadThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeQueryThreads");
+  tsNumOfVnodeQueryThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ratioOfVnodeStreamThreads");
+  tsRatioOfVnodeStreamThreads = pItem->fval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeFetchThreads");
+  tsNumOfVnodeFetchThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfVnodeRsmaThreads");
+  tsNumOfVnodeRsmaThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfQnodeQueryThreads");
+  tsNumOfQnodeQueryThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfSnodeSharedThreads");
+  tsNumOfSnodeStreamThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "numOfSnodeUniqueThreads");
+  tsNumOfSnodeWriteThreads = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rpcQueueMemoryAllowed");
+  tsRpcQueueMemoryAllowed = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "simdEnable");
+  tsSIMDEnable = (bool)pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tagFilterCache");
+  tsTagFilterCache = (bool)pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogExceptDb");
+  tstrncpy(tsSlowLogExceptDb, pItem->str, TSDB_DB_NAME_LEN);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogThresholdTest");
+  tsSlowLogThresholdTest = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogThreshold");
+  tsSlowLogThreshold = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogMaxLen");
+  tsSlowLogMaxLen = pItem->i32;
 
-  tstrncpy(tsSlowLogExceptDb, cfgGetItem(pCfg, "slowLogExceptDb")->str, TSDB_DB_NAME_LEN);
-  tsSlowLogThresholdTest = cfgGetItem(pCfg, "slowLogThresholdTest")->i32;
-  tsSlowLogThreshold = cfgGetItem(pCfg, "slowLogThreshold")->i32;
-  tsSlowLogMaxLen = cfgGetItem(pCfg, "slowLogMaxLen")->i32;
   int32_t scope = 0;
-  TAOS_CHECK_RETURN(taosSetSlowLogScope(cfgGetItem(pCfg, "slowLogScope")->str, &scope));
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "slowLogScope");
+  TAOS_CHECK_RETURN(taosSetSlowLogScope(pItem->str, &scope));
   tsSlowLogScope = scope;
 
-  tsEnableMonitor = cfgGetItem(pCfg, "monitor")->bval;
-  tsMonitorInterval = cfgGetItem(pCfg, "monitorInterval")->i32;
-  tstrncpy(tsMonitorFqdn, cfgGetItem(pCfg, "monitorFqdn")->str, TSDB_FQDN_LEN);
-  tsMonitorPort = (uint16_t)cfgGetItem(pCfg, "monitorPort")->i32;
-  tsMonitorMaxLogs = cfgGetItem(pCfg, "monitorMaxLogs")->i32;
-  tsMonitorComp = cfgGetItem(pCfg, "monitorComp")->bval;
-  tsQueryRspPolicy = cfgGetItem(pCfg, "queryRspPolicy")->i32;
-  tsMonitorLogProtocol = cfgGetItem(pCfg, "monitorLogProtocol")->bval;
-  tsMonitorForceV2 = cfgGetItem(pCfg, "monitorForceV2")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitor");
+  tsEnableMonitor = pItem->bval;
 
-  tsEnableAudit = cfgGetItem(pCfg, "audit")->bval;
-  tsEnableAuditCreateTable = cfgGetItem(pCfg, "auditCreateTable")->bval;
-  tsAuditInterval = cfgGetItem(pCfg, "auditInterval")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorInterval");
+  tsMonitorInterval = pItem->i32;
 
-  tsEnableTelem = cfgGetItem(pCfg, "telemetryReporting")->bval;
-  tsEnableCrashReport = cfgGetItem(pCfg, "crashReporting")->bval;
-  tsTtlChangeOnWrite = cfgGetItem(pCfg, "ttlChangeOnWrite")->bval;
-  tsTtlFlushThreshold = cfgGetItem(pCfg, "ttlFlushThreshold")->i32;
-  tsTelemInterval = cfgGetItem(pCfg, "telemetryInterval")->i32;
-  tsRsyncPort = cfgGetItem(pCfg, "rsyncPort")->i32;
-  tstrncpy(tsTelemServer, cfgGetItem(pCfg, "telemetryServer")->str, TSDB_FQDN_LEN);
-  tstrncpy(tsSnodeAddress, cfgGetItem(pCfg, "snodeAddress")->str, TSDB_FQDN_LEN);
-  tstrncpy(tsCheckpointBackupDir, cfgGetItem(pCfg, "checkpointBackupDir")->str, PATH_MAX);
-  tsTelemPort = (uint16_t)cfgGetItem(pCfg, "telemetryPort")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorFqdn");
+  tstrncpy(tsMonitorFqdn, pItem->str, TSDB_FQDN_LEN);
 
-  tmqMaxTopicNum = cfgGetItem(pCfg, "tmqMaxTopicNum")->i32;
-  tmqRowSize = cfgGetItem(pCfg, "tmqRowSize")->i32;
-  tsMaxTsmaNum = cfgGetItem(pCfg, "maxTsmaNum")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorPort");
+  tsMonitorPort = (uint16_t)pItem->i32;
 
-  tsTransPullupInterval = cfgGetItem(pCfg, "transPullupInterval")->i32;
-  tsCompactPullupInterval = cfgGetItem(pCfg, "compactPullupInterval")->i32;
-  tsMqRebalanceInterval = cfgGetItem(pCfg, "mqRebalanceInterval")->i32;
-  tsTtlUnit = cfgGetItem(pCfg, "ttlUnit")->i32;
-  tsTtlPushIntervalSec = cfgGetItem(pCfg, "ttlPushInterval")->i32;
-  tsTtlBatchDropNum = cfgGetItem(pCfg, "ttlBatchDropNum")->i32;
-  tsTrimVDbIntervalSec = cfgGetItem(pCfg, "trimVDbIntervalSec")->i32;
-  tsUptimeInterval = cfgGetItem(pCfg, "uptimeInterval")->i32;
-  tsQueryRsmaTolerance = cfgGetItem(pCfg, "queryRsmaTolerance")->i32;
-  tsTimeSeriesThreshold = cfgGetItem(pCfg, "timeseriesThreshold")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorMaxLogs");
+  tsMonitorMaxLogs = pItem->i32;
 
-  tsWalFsyncDataSizeLimit = cfgGetItem(pCfg, "walFsyncDataSizeLimit")->i64;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorComp");
+  tsMonitorComp = pItem->bval;
 
-  tsElectInterval = cfgGetItem(pCfg, "syncElectInterval")->i32;
-  tsHeartbeatInterval = cfgGetItem(pCfg, "syncHeartbeatInterval")->i32;
-  tsHeartbeatTimeout = cfgGetItem(pCfg, "syncHeartbeatTimeout")->i32;
-  tsSnapReplMaxWaitN = cfgGetItem(pCfg, "syncSnapReplMaxWaitN")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryRspPolicy");
+  tsQueryRspPolicy = pItem->i32;
 
-  tsArbHeartBeatIntervalSec = cfgGetItem(pCfg, "arbHeartBeatIntervalSec")->i32;
-  tsArbCheckSyncIntervalSec = cfgGetItem(pCfg, "arbCheckSyncIntervalSec")->i32;
-  tsArbSetAssignedTimeoutSec = cfgGetItem(pCfg, "arbSetAssignedTimeoutSec")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorLogProtocol");
+  tsMonitorLogProtocol = pItem->bval;
 
-  tsMndSdbWriteDelta = cfgGetItem(pCfg, "mndSdbWriteDelta")->i64;
-  tsMndLogRetention = cfgGetItem(pCfg, "mndLogRetention")->i64;
-  tsMndSkipGrant = cfgGetItem(pCfg, "skipGrant")->bval;
-  tsEnableWhiteList = cfgGetItem(pCfg, "enableWhiteList")->bval;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "monitorForceV2");
+  tsMonitorForceV2 = pItem->i32;
 
-  tsStartUdfd = cfgGetItem(pCfg, "udf")->bval;
-  tstrncpy(tsUdfdResFuncs, cfgGetItem(pCfg, "udfdResFuncs")->str, sizeof(tsUdfdResFuncs));
-  tstrncpy(tsUdfdLdLibPath, cfgGetItem(pCfg, "udfdLdLibPath")->str, sizeof(tsUdfdLdLibPath));
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "audit");
+  tsEnableAudit = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditCreateTable");
+  tsEnableAuditCreateTable = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "auditInterval");
+  tsAuditInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryReporting");
+  tsEnableTelem = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "crashReporting");
+  tsEnableCrashReport = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlChangeOnWrite");
+  tsTtlChangeOnWrite = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlFlushThreshold");
+  tsTtlFlushThreshold = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryInterval");
+  tsTelemInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "rsyncPort");
+  tsRsyncPort = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryServer");
+  tstrncpy(tsTelemServer, pItem->str, TSDB_FQDN_LEN);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "snodeAddress");
+  tstrncpy(tsSnodeAddress, pItem->str, TSDB_FQDN_LEN);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "checkpointBackupDir");
+  tstrncpy(tsCheckpointBackupDir, pItem->str, PATH_MAX);
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "telemetryPort");
+  tsTelemPort = (uint16_t)pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqMaxTopicNum");
+  tmqMaxTopicNum = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "tmqRowSize");
+  tmqRowSize = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxTsmaNum");
+  tsMaxTsmaNum = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "transPullupInterval");
+  tsTransPullupInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compactPullupInterval");
+  tsCompactPullupInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mqRebalanceInterval");
+  tsMqRebalanceInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlUnit");
+  tsTtlUnit = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlPushInterval");
+  tsTtlPushIntervalSec = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlBatchDropNum");
+  tsTtlBatchDropNum = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "trimVDbIntervalSec");
+  tsTrimVDbIntervalSec = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "uptimeInterval");
+  tsUptimeInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "queryRsmaTolerance");
+  tsQueryRsmaTolerance = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "timeseriesThreshold");
+  tsTimeSeriesThreshold = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "walFsyncDataSizeLimit");
+  tsWalFsyncDataSizeLimit = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncElectInterval");
+  tsElectInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncHeartbeatInterval");
+  tsHeartbeatInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncHeartbeatTimeout");
+  tsHeartbeatTimeout = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "syncSnapReplMaxWaitN");
+  tsSnapReplMaxWaitN = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbHeartBeatIntervalSec");
+  tsArbHeartBeatIntervalSec = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbCheckSyncIntervalSec");
+  tsArbCheckSyncIntervalSec = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "arbSetAssignedTimeoutSec");
+  tsArbSetAssignedTimeoutSec = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mndSdbWriteDelta");
+  tsMndSdbWriteDelta = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mndLogRetention");
+  tsMndLogRetention = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "skipGrant");
+  tsMndSkipGrant = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableWhiteList");
+  tsEnableWhiteList = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udf");
+  tsStartUdfd = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfdResFuncs");
+  tstrncpy(tsUdfdResFuncs, pItem->str, sizeof(tsUdfdResFuncs));
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "udfdLdLibPath");
+  tstrncpy(tsUdfdLdLibPath, pItem->str, sizeof(tsUdfdLdLibPath));
   if (tsQueryBufferSize >= 0) {
     tsQueryBufferSizeBytes = tsQueryBufferSize * 1048576UL;
   }
 
-  tsCacheLazyLoadThreshold = cfgGetItem(pCfg, "cacheLazyLoadThreshold")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "cacheLazyLoadThreshold");
+  tsCacheLazyLoadThreshold = pItem->i32;
 
-  tsFPrecision = cfgGetItem(pCfg, "fPrecision")->fval;
-  tsDPrecision = cfgGetItem(pCfg, "dPrecision")->fval;
-  tsMaxRange = cfgGetItem(pCfg, "maxRange")->i32;
-  tsCurRange = cfgGetItem(pCfg, "curRange")->i32;
-  tsIfAdtFse = cfgGetItem(pCfg, "ifAdtFse")->bval;
-  tstrncpy(tsCompressor, cfgGetItem(pCfg, "compressor")->str, sizeof(tsCompressor));
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "fPrecision");
+  tsFPrecision = pItem->fval;
 
-  tsDisableStream = cfgGetItem(pCfg, "disableStream")->bval;
-  tsStreamBufferSize = cfgGetItem(pCfg, "streamBufferSize")->i64;
-  tsStreamAggCnt = cfgGetItem(pCfg, "streamAggCnt")->i32;
-  tsStreamBufferSize = cfgGetItem(pCfg, "streamBufferSize")->i64;
-  tsStreamCheckpointInterval = cfgGetItem(pCfg, "checkpointInterval")->i32;
-  tsSinkDataRate = cfgGetItem(pCfg, "streamSinkDataRate")->fval;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "dPrecision");
+  tsDPrecision = pItem->fval;
 
-  tsFilterScalarMode = cfgGetItem(pCfg, "filterScalarMode")->bval;
-  tsMaxStreamBackendCache = cfgGetItem(pCfg, "maxStreamBackendCache")->i32;
-  tsPQSortMemThreshold = cfgGetItem(pCfg, "pqSortMemThreshold")->i32;
-  tsResolveFQDNRetryTime = cfgGetItem(pCfg, "resolveFQDNRetryTime")->i32;
-  tsMinDiskFreeSize = cfgGetItem(pCfg, "minDiskFreeSize")->i64;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxRange");
+  tsMaxRange = pItem->i32;
 
-  // tsS3BlockSize = cfgGetItem(pCfg, "s3BlockSize")->i32;
-  // tsS3BlockCacheSize = cfgGetItem(pCfg, "s3BlockCacheSize")->i32;
-  tsS3PageCacheSize = cfgGetItem(pCfg, "s3PageCacheSize")->i32;
-  tsS3UploadDelaySec = cfgGetItem(pCfg, "s3UploadDelaySec")->i32;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "curRange");
+  tsCurRange = pItem->i32;
 
-  tsExperimental = cfgGetItem(pCfg, "experimental")->bval;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ifAdtFse");
+  tsIfAdtFse = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "compressor");
+  tstrncpy(tsCompressor, pItem->str, sizeof(tsCompressor));
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "disableStream");
+  tsDisableStream = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamBufferSize");
+  tsStreamBufferSize = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamAggCnt");
+  tsStreamAggCnt = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "checkpointInterval");
+  tsStreamCheckpointInterval = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "streamSinkDataRate");
+  tsSinkDataRate = pItem->fval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "filterScalarMode");
+  tsFilterScalarMode = pItem->bval;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "maxStreamBackendCache");
+  tsMaxStreamBackendCache = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "pqSortMemThreshold");
+  tsPQSortMemThreshold = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "resolveFQDNRetryTime");
+  tsResolveFQDNRetryTime = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "minDiskFreeSize");
+  tsMinDiskFreeSize = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "s3PageCacheSize");
+  tsS3PageCacheSize = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "s3UploadDelaySec");
+  tsS3UploadDelaySec = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "experimental");
+  tsExperimental = pItem->bval;
 
   // GRANT_CFG_GET;
   TAOS_RETURN(TSDB_CODE_SUCCESS);
@@ -1263,6 +1552,7 @@ static int32_t taosSetAllDebugFlag(SConfig *pCfg, int32_t flag);
 int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDir, const char **envCmd,
                       const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {
   int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
 
   if (tsCfg == NULL) {
     TAOS_CHECK_RETURN(osDefaultInit());
@@ -1273,11 +1563,11 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
 
   if (tsc) {
     tsLogEmbedded = 0;
-    TAOS_CHECK_GOTO(taosAddClientLogCfg(pCfg), NULL, _exit);
+    TAOS_CHECK_GOTO(taosAddClientLogCfg(pCfg), &lino, _exit);
   } else {
     tsLogEmbedded = 1;
-    TAOS_CHECK_GOTO(taosAddClientLogCfg(pCfg), NULL, _exit);
-    TAOS_CHECK_GOTO(taosAddServerLogCfg(pCfg), NULL, _exit);
+    TAOS_CHECK_GOTO(taosAddClientLogCfg(pCfg), &lino, _exit);
+    TAOS_CHECK_GOTO(taosAddServerLogCfg(pCfg), &lino, _exit);
   }
 
   if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != TSDB_CODE_SUCCESS) {
@@ -1291,15 +1581,14 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
   }
 
   if (tsc) {
-    taosSetClientLogCfg(pCfg);
+    TAOS_CHECK_GOTO(taosSetClientLogCfg(pCfg), &lino, _exit);
   } else {
-    taosSetClientLogCfg(pCfg);
-    taosSetServerLogCfg(pCfg);
+    TAOS_CHECK_GOTO(taosSetClientLogCfg(pCfg), &lino, _exit);
+    TAOS_CHECK_GOTO(taosSetServerLogCfg(pCfg), &lino, _exit);
   }
 
-  SConfigItem *pDebugItem = cfgGetItem(pCfg, "debugFlag");
-  if (NULL == pDebugItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
-
+  SConfigItem *pDebugItem = NULL;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pDebugItem, "debugFlag");
   TAOS_CHECK_RETURN(taosSetAllDebugFlag(pCfg, pDebugItem->i32));
 
   if ((code = taosMulModeMkDir(tsLogDir, 0777, true)) != TSDB_CODE_SUCCESS) {
@@ -1313,6 +1602,10 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
   }
 
 _exit:
+  if (TSDB_CODE_SUCCESS != code) {
+    printf("failed to create log at %d since %s:", lino, tstrerror(code));
+  }
+
   cfgCleanup(pCfg);
   TAOS_RETURN(code);
 }
@@ -1326,8 +1619,8 @@ int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char *
   SConfig *pCfg = NULL;
   TAOS_CHECK_RETURN(cfgInit(&pCfg));
 
-  if (cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_NONE) != 0) return -1;
-  if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1;
+  TAOS_CHECK_GOTO(cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_NONE), NULL, _exit);
+  TAOS_CHECK_GOTO(cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) ,NULL, _exit);
 
   if ((code = taosLoadCfg(pCfg, envCmd, cfgDir, envFile, apolloUrl)) != 0) {
     printf("failed to load cfg since %s\n", tstrerror(code));
@@ -1340,7 +1633,14 @@ int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char *
   }
 
   TAOS_CHECK_GOTO(taosSetTfsCfg(pCfg), NULL, _exit);
-  dDebugFlag = cfgGetItem(pCfg, "dDebugFlag")->i32;
+
+  SConfigItem *pItem = NULL;
+  if ((pItem = cfgGetItem(pCfg, "dDebugFlag")) == NULL) {
+    code = TSDB_CODE_CFG_NOT_FOUND;
+    goto _exit;
+  }
+
+  dDebugFlag = pItem->i32;
 
 _exit:
   cfgCleanup(pCfg);
@@ -1694,7 +1994,7 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
 
         const char *locale = pLocaleItem->str;
         const char *charset = pCharsetItem->str;
-        taosSetSystemLocale(locale, charset);
+        TAOS_CHECK_GOTO(taosSetSystemLocale(locale, charset), &lino, _out);
         osSetSystemLocale(locale, charset);
         uInfo("locale set to '%s', charset set to '%s'", locale, charset);
         matched = true;
@@ -1747,20 +2047,22 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
         tstrncpy(tsSmlTsDefaultName, pItem->str, TSDB_COL_NAME_LEN);
         matched = true;
       } else if (strcasecmp("serverPort", name) == 0) {
-        tstrncpy(tsLocalFqdn, cfgGetItem(pCfg, "fqdn")->str, TSDB_FQDN_LEN);
-        tsServerPort = (uint16_t)cfgGetItem(pCfg, "serverPort")->i32;
+        SConfigItem *pFqdnItem = cfgGetItem(pCfg, "fqdn");
+        SConfigItem *pServerPortItem = cfgGetItem(pCfg, "serverPort");
+        SConfigItem *pFirstEpItem = cfgGetItem(pCfg, "firstEp");
+        if (pFqdnItem == NULL || pServerPortItem == NULL || pFirstEpItem == NULL) {
+          uError("failed to get fqdn or serverPort or firstEp from cfg");
+          code = TSDB_CODE_CFG_NOT_FOUND;
+          goto _out;
+        }
+
+        tstrncpy(tsLocalFqdn, pFqdnItem->str, TSDB_FQDN_LEN);
+        tsServerPort = (uint16_t)pServerPortItem->i32;
         (void)snprintf(tsLocalEp, sizeof(tsLocalEp), "%s:%u", tsLocalFqdn, tsServerPort);
 
         char defaultFirstEp[TSDB_EP_LEN] = {0};
         (void)snprintf(defaultFirstEp, TSDB_EP_LEN, "%s:%u", tsLocalFqdn, tsServerPort);
 
-        SConfigItem *pFirstEpItem = cfgGetItem(pCfg, "firstEp");
-        if (pFirstEpItem == NULL) {
-          uError("failed to get firstEp from cfg");
-          code = TSDB_CODE_CFG_NOT_FOUND;
-          goto _out;
-        }
-
         SEp          firstEp = {0};
         TAOS_CHECK_GOTO(
             taosGetFqdnPortFromEp(strlen(pFirstEpItem->str) == 0 ? defaultFirstEp : pFirstEpItem->str, &firstEp), &lino,
@@ -1859,9 +2161,8 @@ int32_t taosCfgDynamicOptions(SConfig *pCfg, const char *name, bool forServer) {
 }
 
 int32_t taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal) {
-  SConfigItem *pItem = cfgGetItem(tsCfg, flagName);
-  if (!pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
-
+  SConfigItem *pItem = NULL;
+  TAOS_CHECK_GET_CFG_ITEM(tsCfg, pItem, flagName);
   pItem->i32 = flagVal;
   if (pFlagPtr != NULL) {
     *pFlagPtr = flagVal;
@@ -1890,8 +2191,8 @@ static int32_t taosSetAllDebugFlag(SConfig *pCfg, int32_t flag) {
   if (flag == 0) TAOS_RETURN(TSDB_CODE_SUCCESS); // just ignore
 
   SArray      *noNeedToSetVars = NULL;
-  SConfigItem *pItem = cfgGetItem(pCfg, "debugFlag");
-  if (NULL == pItem) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
+  SConfigItem *pItem = NULL;
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "debugFlag");
 
   pItem->i32 = flag;
   noNeedToSetVars = pItem->array;