feat: send monitor information in multi-process mode

include/common/tmsg.h

@@ -679,6 +679,18 @@ typedef struct {
   char    charset[TD_LOCALE_LEN];     // tsCharset
 } SClusterCfg;
 
+typedef struct {
+  int32_t openVnodes;
+  int32_t totalVnodes;
+  int32_t masterNum;
+  int64_t numOfSelectReqs;
+  int64_t numOfInsertReqs;
+  int64_t numOfInsertSuccessReqs;
+  int64_t numOfBatchInsertReqs;
+  int64_t numOfBatchInsertSuccessReqs;
+  int64_t errors;
+} SVnodesStat;
+
 typedef struct {
   int32_t vgId;
   int8_t  role;

include/common/tmsgdef.h

@@ -216,6 +216,15 @@ enum {
   TD_NEW_MSG_SEG(TDMT_SCH_MSG)
   TD_DEF_MSG_TYPE(TDMT_SCH_LINK_BROKEN, "scheduler-link-broken", NULL, NULL)
   
+  // Monitor info exchange between processes
+  TD_NEW_MSG_SEG(TDMT_MON_MSG)
+  TD_DEF_MSG_TYPE(TDMT_MON_MM_INFO, "monitor-minfo", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MON_VM_INFO, "monitor-vinfo", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MON_QM_INFO, "monitor-qinfo", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MON_SM_INFO, "monitor-sinfo", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MON_BM_INFO, "monitor-binfo", NULL, NULL)
+  TD_DEF_MSG_TYPE(TDMT_MON_VM_LOAD, "monitor-vload", NULL, NULL)
+
 #if defined(TD_MSG_NUMBER_)
   TDMT_MAX
 #endif

include/libs/monitor/monitor.h

@@ -19,6 +19,7 @@
 #include "tarray.h"
 #include "tdef.h"
 #include "tlog.h"
+#include "tmsg.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -29,6 +30,44 @@ extern "C" {
 #define MON_VER_LEN    12
 #define MON_LOG_LEN    1024
 
+typedef struct {
+  int64_t   ts;
+  ELogLevel level;
+  char      content[MON_LOG_LEN];
+} SMonLogItem;
+
+typedef struct {
+  SArray *logs;  // array of SMonLogItem
+  int32_t numOfErrorLogs;
+  int32_t numOfInfoLogs;
+  int32_t numOfDebugLogs;
+  int32_t numOfTraceLogs;
+} SMonLogs;
+
+typedef struct {
+  char      name[TSDB_FILENAME_LEN];
+  int8_t    level;
+  SDiskSize size;
+} SMonDiskDesc;
+
+typedef struct {
+  double  cpu_engine;
+  double  cpu_system;
+  float   cpu_cores;
+  int64_t mem_engine;     // KB
+  int64_t mem_system;     // KB
+  int64_t mem_total;      // KB
+  int64_t disk_engine;    // Byte
+  int64_t disk_used;      // Byte
+  int64_t disk_total;     // Byte
+  int64_t net_in;         // bytes
+  int64_t net_out;        // bytes
+  int64_t io_read;        // bytes
+  int64_t io_write;       // bytes
+  int64_t io_read_disk;   // bytes
+  int64_t io_write_disk;  // bytes
+} SMonSysInfo;
+
 typedef struct {
   int32_t dnode_id;
   char    dnode_ep[TSDB_EP_LEN];
@@ -36,6 +75,19 @@ typedef struct {
   int32_t protocol;
 } SMonBasicInfo;
 
+typedef struct {
+  float        uptime;  // day
+  int8_t       has_mnode;
+  SMonDiskDesc logdir;
+  SMonDiskDesc tempdir;
+} SMonDnodeInfo;
+
+typedef struct {
+  SMonBasicInfo basic;
+  SMonDnodeInfo dnode;
+  SMonSysInfo   sys;
+} SMonDmInfo;
+
 typedef struct {
   int32_t dnode_id;
   char    dnode_ep[TSDB_EP_LEN];
@@ -87,46 +139,57 @@ typedef struct {
 } SMonGrantInfo;
 
 typedef struct {
-  float   uptime;  // day
-  double  cpu_engine;
-  double  cpu_system;
-  float   cpu_cores;
-  int64_t mem_engine;   // KB
-  int64_t mem_system;   // KB
-  int64_t mem_total;    // KB
-  int64_t disk_engine;  // Byte
-  int64_t disk_used;    // Byte
-  int64_t disk_total;   // Byte
-  int64_t net_in;       // bytes
-  int64_t net_out;      // bytes
-  int64_t io_read;      // bytes
-  int64_t io_write;     // bytes
-  int64_t io_read_disk;   // bytes
-  int64_t io_write_disk;  // bytes
-  int64_t req_select;
-  int64_t req_insert;
-  int64_t req_insert_success;
-  int64_t req_insert_batch;
-  int64_t req_insert_batch_success;
-  int32_t errors;
-  int32_t vnodes_num;
-  int32_t masters;
-  int8_t  has_mnode;
-} SMonDnodeInfo;
+  SMonClusterInfo cluster;
+  SMonVgroupInfo  vgroup;
+  SMonGrantInfo   grant;
+  SMonSysInfo     sys;
+  SMonLogs        logs;
+} SMonMmInfo;
 
-typedef struct {
-  char      name[TSDB_FILENAME_LEN];
-  int8_t    level;
-  SDiskSize size;
-} SMonDiskDesc;
+int32_t tSerializeSMonMmInfo(void *buf, int32_t bufLen, SMonMmInfo *pInfo);
+int32_t tDeserializeSMonMmInfo(void *buf, int32_t bufLen, SMonMmInfo *pInfo);
+void    tFreeSMonMmInfo(SMonMmInfo *pInfo);
 
 typedef struct {
   SArray *datadirs;  // array of SMonDiskDesc
-  SMonDiskDesc logdir;
-  SMonDiskDesc tempdir;
 } SMonDiskInfo;
 
-typedef struct SMonInfo SMonInfo;
+typedef struct {
+  SMonDiskInfo tfs;
+  SVnodesStat  vstat;
+  SMonSysInfo  sys;
+  SMonLogs     logs;
+} SMonVmInfo;
+
+int32_t tSerializeSMonVmInfo(void *buf, int32_t bufLen, SMonVmInfo *pInfo);
+int32_t tDeserializeSMonVMmInfo(void *buf, int32_t bufLen, SMonVmInfo *pInfo);
+void    tFreeSMonVmInfo(SMonVmInfo *pInfo);
+
+typedef struct {
+  SMonSysInfo sys;
+  SMonLogs    logs;
+} SMonQmInfo;
+
+int32_t tSerializeSMonQmInfo(void *buf, int32_t bufLen, SMonQmInfo *pInfo);
+int32_t tDeserializeSMonQMmInfo(void *buf, int32_t bufLen, SMonQmInfo *pInfo);
+void    tFreeSMonQmInfo(SMonQmInfo *pInfo);
+
+typedef struct {
+  SMonSysInfo sys;
+  SMonLogs    logs;
+} SMonSmInfo;
+
+int32_t tSerializeSMonSmInfo(void *buf, int32_t bufLen, SMonSmInfo *pInfo);
+int32_t tDeserializeSMonSmInfo(void *buf, int32_t bufLen, SMonSmInfo *pInfo);
+void    tFreeSMonSmInfo(SMonSmInfo *pInfo);
+typedef struct {
+  SMonSysInfo sys;
+  SMonLogs    logs;
+} SMonBmInfo;
+
+int32_t tSerializeSMonBmInfo(void *buf, int32_t bufLen, SMonBmInfo *pInfo);
+int32_t tDeserializeSMonBmInfo(void *buf, int32_t bufLen, SMonBmInfo *pInfo);
+void    tFreeSMonBmInfo(SMonBmInfo *pInfo);
 
 typedef struct {
   const char *server;
@@ -138,16 +201,14 @@ typedef struct {
 int32_t monInit(const SMonCfg *pCfg);
 void    monCleanup();
 void    monRecordLog(int64_t ts, ELogLevel level, const char *content);
-
-SMonInfo *monCreateMonitorInfo();
-void      monSetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo);
-void      monSetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo);
-void      monSetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo);
-void      monSetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo);
-void      monSetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo);
-void      monSetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo);
-void      monSendReport(SMonInfo *pMonitor);
-void      monCleanupMonitorInfo(SMonInfo *pMonitor);
+int32_t monGetLogs(SMonLogs *logs);
+void    monSetDmInfo(SMonDmInfo *pInfo);
+void    monSetMmInfo(SMonMmInfo *pInfo);
+void    monSetVmInfo(SMonVmInfo *pInfo);
+void    monSetQmInfo(SMonQmInfo *pInfo);
+void    monSetSmInfo(SMonSmInfo *pInfo);
+void    monSetBmInfo(SMonBmInfo *pInfo);
+void    monSendReport();
 
 #ifdef __cplusplus
 }

include/os/osSysinfo.h

@@ -44,8 +44,8 @@ int32_t taosGetTotalMemory(int64_t *totalKB);
 int32_t taosGetProcMemory(int64_t *usedKB);
 int32_t taosGetSysMemory(int64_t *usedKB);
 int32_t taosGetDiskSize(char *dataDir, SDiskSize *diskSize);
-int32_t taosGetProcIO(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int64_t *write_bytes);
-int32_t taosGetCardInfo(int64_t *receive_bytes, int64_t *transmit_bytes);
+void    taosGetProcIODelta(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int64_t *write_bytes);
+void    taosGetCardInfoDelta(int64_t *receive_bytes, int64_t *transmit_bytes);
 
 void    taosKillSystem();
 int32_t taosGetSystemUUID(char *uid, int32_t uidlen);

source/dnode/mgmt/dm/dmHandle.c

@@ -212,4 +212,7 @@ void dmInitMsgHandle(SMgmtWrapper *pWrapper) {
   dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, dmProcessStatusMsg, DEFAULT_HANDLE);
   dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
   dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
+
+  // Monitor info exchange between processes
+  dndSetMsgHandle(pWrapper, TDMT_MON_DISK_INFO, dmProcessStatusMsg, DEFAULT_HANDLE);
 }

source/dnode/mgmt/dm/dmMonitor.c

@@ -14,7 +14,7 @@
  */
 
 #define _DEFAULT_SOURCE
-#include "dndInt.h"
+#include "dmInt.h"
 
 static int32_t dmGetMonitorDiskInfo(SDnode *pDnode, SMonDiskInfo *pInfo) {
   tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));
@@ -105,3 +105,35 @@ void dmSendMonitorReport(SDnode *pDnode) {
   monSendReport(pMonitor);
   monCleanupMonitorInfo(pMonitor);
 }
+
+int32_t dmSetDiskInfo(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SDnode      *pDnode = pMgmt->pDnode;
+  SMonDiskInfo info = {0};
+
+  if (tDeserializeSMonDiskInfo(pMsg->rpcMsg.pCont, pMsg->rpcMsg.contLen, &info) != 0) {
+    dError("failed to parse diskinfo since %s", terrstr());
+    return 0;
+  }
+
+  taosWLockLatch(&pMgmt->latch);
+  memcpy(&pMgmt->diskInfo, &info, sizeof(SMonDiskInfo));
+  taosWUnLockLatch(&pMgmt->latch);
+
+  return 0;
+}
+
+int32_t dmSetVnodeStat(SDnodeMgmt *pMgmt, SNodeMsg *pMsg) {
+  SDnode      *pDnode = pMgmt->pDnode;
+  SVnodesStat info = {0};
+
+  if (tDeserializeSMonDiskInfo(pMsg->rpcMsg.pCont, pMsg->rpcMsg.contLen, &info) != 0) {
+    dError("failed to parse diskinfo since %s", terrstr());
+    return 0;
+  }
+
+  taosWLockLatch(&pMgmt->latch);
+  memcpy(&pMgmt->diskInfo, &info, sizeof(SMonDiskInfo));
+  taosWUnLockLatch(&pMgmt->latch);
+
+  return 0;
+}
\ No newline at end of file

source/dnode/mgmt/dm/dmWorker.c

@@ -78,6 +78,9 @@ static void dmProcessQueue(SQueueInfo *pInfo, SNodeMsg *pMsg) {
     case TDMT_MND_GRANT_RSP:
       code = dmProcessGrantRsp(pMgmt, pMsg);
       break;
+    case TDMT_MON_DISK_INFO_RSP:
+      code = dmSetDiskInfo(pMgmt, pMsg);
+      break;
     default:
       code = dmProcessCDnodeReq(pMgmt->pDnode, pMsg);
       break;

source/dnode/mgmt/inc/dmInt.h

@@ -37,6 +37,11 @@ typedef struct SDnodeMgmt {
   const char   *path;
   SDnode       *pDnode;
   SMgmtWrapper *pWrapper;
+
+  // monitor infos
+  SMonDiskInfo   diskInfo;
+  SMonVnodesStat vnodesStat;
+  SMonVnodesLoad vnodesLoad;
 } SDnodeMgmt;
 
 // dmFile.c
@@ -54,6 +59,9 @@ int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 int32_t dmProcessCDnodeReq(SDnode *pDnode, SNodeMsg *pMsg);
 
 // dmMonitor.c
+int32_t dmSetDiskInfo(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmSetVnodesStat(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
+int32_t dmSetVnodesLoad(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
 void    dmSendMonitorReport(SDnode *pDnode);
 
 // dmWorker.c

source/libs/monitor/inc/monInt.h

@@ -18,43 +18,32 @@
 
 #include "monitor.h"
 
-#include "tarray.h"
 #include "tjson.h"
 
 typedef struct {
-  int64_t   ts;
-  ELogLevel level;
-  char      content[MON_LOG_LEN];
-} SMonLogItem;
-
-typedef struct {
-  int64_t time;
-  int64_t req_select;
-  int64_t req_insert;
-  int64_t req_insert_batch;
-  int64_t net_in;
-  int64_t net_out;
-  int64_t io_read;
-  int64_t io_write;
-  int64_t io_read_disk;
-  int64_t io_write_disk;
-} SMonState;
-
-typedef struct SMonInfo {
   int64_t    curTime;
-  SMonState lastState;
-  SArray   *logs;  // array of SMonLogItem
+  int64_t    lastTime;
   SJson     *pJson;
+  SMonLogs   logs;
+  SMonDmInfo dmInfo;
+  SMonMmInfo mmInfo;
+  SMonVmInfo vmInfo;
+  SMonSmInfo smInfo;
+  SMonQmInfo qmInfo;
+  SMonBmInfo bmInfo;
 } SMonInfo;
 
 typedef struct {
   TdThreadMutex lock;
   SArray       *logs;  // array of SMonLogItem
-  int32_t         maxLogs;
-  const char     *server;
-  uint16_t        port;
-  bool            comp;
-  SMonState       state;
+  SMonCfg       cfg;
+  int64_t       lastTime;
+  SMonDmInfo    dmInfo;
+  SMonMmInfo    mmInfo;
+  SMonVmInfo    vmInfo;
+  SMonSmInfo    smInfo;
+  SMonQmInfo    qmInfo;
+  SMonBmInfo    bmInfo;
 } SMonitor;
 
 #ifdef __cplusplus

source/libs/monitor/src/monMsg.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _DEFAULT_SOURCE
+#include "monInt.h"
+#include "tcoding.h"
+#include "tencode.h"
+
+int32_t tSerializeSMonMmInfo(void *buf, int32_t bufLen, SMonMmInfo *pInfo);
+int32_t tDeserializeSMonMmInfo(void *buf, int32_t bufLen, SMonMmInfo *pInfo);
+void    tFreeSMonMmInfo(SMonMmInfo *pInfo) {
+  taosArrayDestroy(pInfo->logs.logs);
+  pInfo->logs.logs = NULL;
+}
+
+int32_t tSerializeSMonVmInfo(void *buf, int32_t bufLen, SMonVmInfo *pInfo);
+int32_t tDeserializeSMonVMmInfo(void *buf, int32_t bufLen, SMonVmInfo *pInfo);
+void    tFreeSMonVmInfo(SMonVmInfo *pInfo) {
+  taosArrayDestroy(pInfo->logs.logs);
+  pInfo->logs.logs = NULL;
+}
+
+int32_t tSerializeSMonQmInfo(void *buf, int32_t bufLen, SMonQmInfo *pInfo);
+int32_t tDeserializeSMonQMmInfo(void *buf, int32_t bufLen, SMonQmInfo *pInfo);
+void    tFreeSMonQmInfo(SMonQmInfo *pInfo) {
+  taosArrayDestroy(pInfo->logs.logs);
+  pInfo->logs.logs = NULL;
+}
+
+int32_t tSerializeSMonSmInfo(void *buf, int32_t bufLen, SMonSmInfo *pInfo);
+int32_t tDeserializeSMonSmInfo(void *buf, int32_t bufLen, SMonSmInfo *pInfo);
+void    tFreeSMonSmInfo(SMonSmInfo *pInfo) {
+  taosArrayDestroy(pInfo->logs.logs);
+  pInfo->logs.logs = NULL;
+}
+
+int32_t tSerializeSMonBmInfo(void *buf, int32_t bufLen, SMonBmInfo *pInfo);
+int32_t tDeserializeSMonBmInfo(void *buf, int32_t bufLen, SMonBmInfo *pInfo);
+void    tFreeSMonBmInfo(SMonBmInfo *pInfo) {
+  taosArrayDestroy(pInfo->logs.logs);
+  pInfo->logs.logs = NULL;
+}
\ No newline at end of file

source/libs/monitor/src/monitor.c

@@ -17,7 +17,6 @@
 #include "monInt.h"
 #include "taoserror.h"
 #include "thttp.h"
-#include "tlog.h"
 #include "ttime.h"
 
 static SMonitor tsMonitor = {0};
@@ -25,7 +24,7 @@ static SMonitor tsMonitor = {0};
 void monRecordLog(int64_t ts, ELogLevel level, const char *content) {
   taosThreadMutexLock(&tsMonitor.lock);
   int32_t size = taosArrayGetSize(tsMonitor.logs);
-  if (size < tsMonitor.maxLogs) {
+  if (size < tsMonitor.cfg.maxLogs) {
     SMonLogItem  item = {.ts = ts, .level = level};
     SMonLogItem *pItem = taosArrayPush(tsMonitor.logs, &item);
     if (pItem != NULL) {
@@ -35,6 +34,68 @@ void monRecordLog(int64_t ts, ELogLevel level, const char *content) {
   taosThreadMutexUnlock(&tsMonitor.lock);
 }
 
+int32_t monGetLogs(SMonLogs *logs) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  logs->logs = taosArrayDup(tsMonitor.logs);
+  logs->numOfInfoLogs = tsNumOfInfoLogs;
+  logs->numOfErrorLogs = tsNumOfErrorLogs;
+  logs->numOfDebugLogs = tsNumOfDebugLogs;
+  logs->numOfTraceLogs = tsNumOfTraceLogs;
+  tsNumOfInfoLogs = 0;
+  tsNumOfErrorLogs = 0;
+  tsNumOfDebugLogs = 0;
+  tsNumOfTraceLogs = 0;
+  taosArrayClear(tsMonitor.logs);
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  if (logs->logs == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return -1;
+  }
+  return 0;
+}
+
+void monSetDmInfo(SMonDmInfo *pInfo) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  memcpy(&tsMonitor.dmInfo, pInfo, sizeof(SMonDmInfo));
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  memset(pInfo, 0, sizeof(SMonDmInfo));
+}
+
+void monSetMmInfo(SMonMmInfo *pInfo) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  memcpy(&tsMonitor.mmInfo, pInfo, sizeof(SMonMmInfo));
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  memset(pInfo, 0, sizeof(SMonMmInfo));
+}
+
+void monSetVmInfo(SMonVmInfo *pInfo) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  memcpy(&tsMonitor.vmInfo, pInfo, sizeof(SMonVmInfo));
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  memset(pInfo, 0, sizeof(SMonVmInfo));
+}
+
+void monSetQmInfo(SMonQmInfo *pInfo) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  memcpy(&tsMonitor.qmInfo, pInfo, sizeof(SMonQmInfo));
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  memset(pInfo, 0, sizeof(SMonQmInfo));
+}
+
+void monSetSmInfo(SMonSmInfo *pInfo) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  memcpy(&tsMonitor.smInfo, pInfo, sizeof(SMonSmInfo));
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  memset(pInfo, 0, sizeof(SMonSmInfo));
+}
+
+void monSetBmInfo(SMonBmInfo *pInfo) {
+  taosThreadMutexLock(&tsMonitor.lock);
+  memcpy(&tsMonitor.bmInfo, pInfo, sizeof(SMonBmInfo));
+  taosThreadMutexUnlock(&tsMonitor.lock);
+  memset(pInfo, 0, sizeof(SMonBmInfo));
+}
+
 int32_t monInit(const SMonCfg *pCfg) {
   tsMonitor.logs = taosArrayInit(16, sizeof(SMonLogItem));
   if (tsMonitor.logs == NULL) {
@@ -42,12 +103,9 @@ int32_t monInit(const SMonCfg *pCfg) {
     return -1;
   }
 
-  tsMonitor.maxLogs = pCfg->maxLogs;
-  tsMonitor.server = pCfg->server;
-  tsMonitor.port = pCfg->port;
-  tsMonitor.comp = pCfg->comp;
+  tsMonitor.cfg = *pCfg;
   tsLogFp = monRecordLog;
-  tsMonitor.state.time = taosGetTimestampMs();
+  tsMonitor.lastTime = taosGetTimestampMs();
   taosThreadMutexInit(&tsMonitor.lock, NULL);
   return 0;
 }
@@ -56,42 +114,65 @@ void monCleanup() {
   tsLogFp = NULL;
   taosArrayDestroy(tsMonitor.logs);
   tsMonitor.logs = NULL;
+  tFreeSMonMmInfo(&tsMonitor.mmInfo);
+  tFreeSMonVmInfo(&tsMonitor.vmInfo);
+  tFreeSMonSmInfo(&tsMonitor.smInfo);
+  tFreeSMonQmInfo(&tsMonitor.qmInfo);
+  tFreeSMonBmInfo(&tsMonitor.bmInfo);
   taosThreadMutexDestroy(&tsMonitor.lock);
 }
 
-SMonInfo *monCreateMonitorInfo() {
+static void monCleanupMonitorInfo(SMonInfo *pMonitor) {
+  tsMonitor.lastTime = pMonitor->curTime;
+  taosArrayDestroy(pMonitor->logs.logs);
+  tFreeSMonMmInfo(&pMonitor->mmInfo);
+  tFreeSMonVmInfo(&pMonitor->vmInfo);
+  tFreeSMonSmInfo(&pMonitor->smInfo);
+  tFreeSMonQmInfo(&pMonitor->qmInfo);
+  tFreeSMonBmInfo(&pMonitor->bmInfo);
+  tjsonDelete(pMonitor->pJson);
+  taosMemoryFree(pMonitor);
+}
+
+static SMonInfo *monCreateMonitorInfo() {
   SMonInfo *pMonitor = taosMemoryCalloc(1, sizeof(SMonInfo));
   if (pMonitor == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
+  monGetLogs(&pMonitor->logs);
+
   taosThreadMutexLock(&tsMonitor.lock);
-  pMonitor->logs = taosArrayDup(tsMonitor.logs);
-  taosArrayClear(tsMonitor.logs);
+  memcpy(&pMonitor->dmInfo, &tsMonitor.dmInfo, sizeof(SMonDmInfo));
+  memcpy(&pMonitor->mmInfo, &tsMonitor.mmInfo, sizeof(SMonMmInfo));
+  memcpy(&pMonitor->vmInfo, &tsMonitor.vmInfo, sizeof(SMonVmInfo));
+  memcpy(&pMonitor->smInfo, &tsMonitor.smInfo, sizeof(SMonSmInfo));
+  memcpy(&pMonitor->qmInfo, &tsMonitor.qmInfo, sizeof(SMonQmInfo));
+  memcpy(&pMonitor->bmInfo, &tsMonitor.bmInfo, sizeof(SMonBmInfo));
+  memset(&tsMonitor.dmInfo, 0, sizeof(SMonDmInfo));
+  memset(&tsMonitor.mmInfo, 0, sizeof(SMonMmInfo));
+  memset(&tsMonitor.vmInfo, 0, sizeof(SMonVmInfo));
+  memset(&tsMonitor.smInfo, 0, sizeof(SMonSmInfo));
+  memset(&tsMonitor.qmInfo, 0, sizeof(SMonQmInfo));
+  memset(&tsMonitor.bmInfo, 0, sizeof(SMonBmInfo));
   taosThreadMutexUnlock(&tsMonitor.lock);
 
   pMonitor->pJson = tjsonCreateObject();
-  if (pMonitor->pJson == NULL || pMonitor->logs == NULL) {
+  if (pMonitor->pJson == NULL || pMonitor->logs.logs == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     monCleanupMonitorInfo(pMonitor);
     return NULL;
   }
 
   pMonitor->curTime = taosGetTimestampMs();
-  pMonitor->lastState = tsMonitor.state;
+  pMonitor->lastTime = tsMonitor.lastTime;
   return pMonitor;
 }
 
-void monCleanupMonitorInfo(SMonInfo *pMonitor) {
-  tsMonitor.state = pMonitor->lastState;
-  tsMonitor.state.time = pMonitor->curTime;
-  taosArrayDestroy(pMonitor->logs);
-  tjsonDelete(pMonitor->pJson);
-  taosMemoryFree(pMonitor);
-}
+static void monGenBasicJson(SMonInfo *pMonitor) {
+  SMonBasicInfo *pInfo = &pMonitor->dmInfo.basic;
 
-void monSetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo) {
   SJson *pJson = pMonitor->pJson;
   char   buf[40] = {0};
   taosFormatUtcTime(buf, sizeof(buf), pMonitor->curTime, TSDB_TIME_PRECISION_MILLI);
@@ -104,7 +185,9 @@ void monSetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo) {
   tjsonAddDoubleToObject(pJson, "protocol", pInfo->protocol);
 }
 
-void monSetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo) {
+static void monGenClusterJson(SMonInfo *pMonitor) {
+  SMonClusterInfo *pInfo = &pMonitor->mmInfo.cluster;
+
   SJson *pJson = tjsonCreateObject();
   if (pJson == NULL) return;
   if (tjsonAddItemToObject(pMonitor->pJson, "cluster_info", pJson) != 0) {
@@ -154,7 +237,9 @@ void monSetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo) {
   }
 }
 
-void monSetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo) {
+static void monGenVgroupJson(SMonInfo *pMonitor) {
+  SMonVgroupInfo *pInfo = &pMonitor->mmInfo.vgroup;
+
   SJson *pJson = tjsonAddArrayToObject(pMonitor->pJson, "vgroup_infos");
   if (pJson == NULL) return;
 
@@ -190,7 +275,9 @@ void monSetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo) {
   }
 }
 
-void monSetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo) {
+static void monGenGrantJson(SMonInfo *pMonitor) {
+  SMonGrantInfo *pInfo = &pMonitor->mmInfo.grant;
+
   SJson *pJson = tjsonCreateObject();
   if (pJson == NULL) return;
   if (tjsonAddItemToObject(pMonitor->pJson, "grant_info", pJson) != 0) {
@@ -203,7 +290,11 @@ void monSetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo) {
   tjsonAddDoubleToObject(pJson, "timeseries_total", pInfo->timeseries_total);
 }
 
-void monSetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo) {
+static void monGenDnodeJson(SMonInfo *pMonitor) {
+  SMonDnodeInfo *pInfo = &pMonitor->dmInfo.dnode;
+  SMonSysInfo   *pSys = &pMonitor->dmInfo.sys;
+  SVnodesStat   *pStat = &pMonitor->vmInfo.vstat;
+
   SJson *pJson = tjsonCreateObject();
   if (pJson == NULL) return;
   if (tjsonAddItemToObject(pMonitor->pJson, "dnode_info", pJson) != 0) {
@@ -211,58 +302,83 @@ void monSetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo) {
     return;
   }
 
-  SMonState *pLast = &pMonitor->lastState;
-  double     interval = (pMonitor->curTime - pLast->time) / 1000.0;
-  double     req_select_rate = (pInfo->req_select - pLast->req_select) / interval;
-  double     req_insert_rate = (pInfo->req_insert - pLast->req_insert) / interval;
-  double     req_insert_batch_rate = (pInfo->req_insert_batch - pLast->req_insert_batch) / interval;
-  double     net_in_rate = (pInfo->net_in - pLast->net_in) / interval;
-  double     net_out_rate = (pInfo->net_out - pLast->net_out) / interval;
-  double     io_read_rate = (pInfo->io_read - pLast->io_read) / interval;
-  double     io_write_rate = (pInfo->io_write - pLast->io_write) / interval;
-  double     io_read_disk_rate = (pInfo->io_read_disk - pLast->io_read_disk) / interval;
-  double     io_write_disk_rate = (pInfo->io_write_disk - pLast->io_write_disk) / interval;
-  pLast->req_select = pInfo->req_select;
-  pLast->req_insert = pInfo->req_insert;
-  pLast->req_insert_batch = pInfo->req_insert_batch;
-  pLast->net_in = pInfo->net_in;
-  pLast->net_out = pInfo->net_out;
-  pLast->io_read = pInfo->io_read;
-  pLast->io_write = pInfo->io_write;
-  pLast->io_read_disk = pInfo->io_read_disk;
-  pLast->io_write_disk = pInfo->io_write_disk;
+  double interval = (pMonitor->curTime - pMonitor->lastTime) / 1000.0;
+  if (pMonitor->curTime - pMonitor->lastTime == 0) {
+    interval = 1;
+  }
+
+  double cpu_engine = 0;
+  double mem_engine = 0;
+  double net_in = 0;
+  double net_out = 0;
+  double io_read = 0;
+  double io_write = 0;
+  double io_read_disk = 0;
+  double io_write_disk = 0;
+
+  SMonSysInfo *sysArrays[6];
+  sysArrays[0] = &pMonitor->dmInfo.sys;
+  sysArrays[1] = &pMonitor->mmInfo.sys;
+  sysArrays[2] = &pMonitor->vmInfo.sys;
+  sysArrays[3] = &pMonitor->qmInfo.sys;
+  sysArrays[4] = &pMonitor->smInfo.sys;
+  sysArrays[5] = &pMonitor->bmInfo.sys;
+  for (int32_t i = 0; i < 6; ++i) {
+    cpu_engine += sysArrays[i]->cpu_engine;
+    mem_engine += sysArrays[i]->mem_engine;
+    net_in += sysArrays[i]->net_in;
+    net_out += sysArrays[i]->net_out;
+    io_read += sysArrays[i]->io_read;
+    io_write += sysArrays[i]->io_write;
+    io_read_disk += sysArrays[i]->io_read_disk;
+    io_write_disk += sysArrays[i]->io_write_disk;
+  }
+
+  double req_select_rate = pStat->numOfSelectReqs / interval;
+  double req_insert_rate = pStat->numOfInsertReqs / interval;
+  double req_insert_batch_rate = pStat->numOfBatchInsertReqs / interval;
+  double net_in_rate = net_in / interval;
+  double net_out_rate = net_out / interval;
+  double io_read_rate = io_read / interval;
+  double io_write_rate = io_write / interval;
+  double io_read_disk_rate = io_read_disk / interval;
+  double io_write_disk_rate = io_write_disk / interval;
 
   tjsonAddDoubleToObject(pJson, "uptime", pInfo->uptime);
-  tjsonAddDoubleToObject(pJson, "cpu_engine", pInfo->cpu_engine);
-  tjsonAddDoubleToObject(pJson, "cpu_system", pInfo->cpu_system);
-  tjsonAddDoubleToObject(pJson, "cpu_cores", pInfo->cpu_cores);
-  tjsonAddDoubleToObject(pJson, "mem_engine", pInfo->mem_engine);
-  tjsonAddDoubleToObject(pJson, "mem_system", pInfo->mem_system);
-  tjsonAddDoubleToObject(pJson, "mem_total", pInfo->mem_total);
-  tjsonAddDoubleToObject(pJson, "disk_engine", pInfo->disk_engine);
-  tjsonAddDoubleToObject(pJson, "disk_used", pInfo->disk_used);
-  tjsonAddDoubleToObject(pJson, "disk_total", pInfo->disk_total);
+  tjsonAddDoubleToObject(pJson, "cpu_engine", cpu_engine);
+  tjsonAddDoubleToObject(pJson, "cpu_system", pSys->cpu_system);
+  tjsonAddDoubleToObject(pJson, "cpu_cores", pSys->cpu_cores);
+  tjsonAddDoubleToObject(pJson, "mem_engine", mem_engine);
+  tjsonAddDoubleToObject(pJson, "mem_system", pSys->mem_system);
+  tjsonAddDoubleToObject(pJson, "mem_total", pSys->mem_total);
+  tjsonAddDoubleToObject(pJson, "disk_engine", pSys->disk_engine);
+  tjsonAddDoubleToObject(pJson, "disk_used", pSys->disk_used);
+  tjsonAddDoubleToObject(pJson, "disk_total", pSys->disk_total);
   tjsonAddDoubleToObject(pJson, "net_in", net_in_rate);
   tjsonAddDoubleToObject(pJson, "net_out", net_out_rate);
   tjsonAddDoubleToObject(pJson, "io_read", io_read_rate);
   tjsonAddDoubleToObject(pJson, "io_write", io_write_rate);
   tjsonAddDoubleToObject(pJson, "io_read_disk", io_read_disk_rate);
   tjsonAddDoubleToObject(pJson, "io_write_disk", io_write_disk_rate);
-  tjsonAddDoubleToObject(pJson, "req_select", pInfo->req_select);
+  tjsonAddDoubleToObject(pJson, "req_select", pStat->numOfSelectReqs);
   tjsonAddDoubleToObject(pJson, "req_select_rate", req_select_rate);
-  tjsonAddDoubleToObject(pJson, "req_insert", pInfo->req_insert);
-  tjsonAddDoubleToObject(pJson, "req_insert_success", pInfo->req_insert_success);
+  tjsonAddDoubleToObject(pJson, "req_insert", pStat->numOfInsertReqs);
+  tjsonAddDoubleToObject(pJson, "req_insert_success", pStat->numOfInsertSuccessReqs);
   tjsonAddDoubleToObject(pJson, "req_insert_rate", req_insert_rate);
-  tjsonAddDoubleToObject(pJson, "req_insert_batch", pInfo->req_insert_batch);
-  tjsonAddDoubleToObject(pJson, "req_insert_batch_success", pInfo->req_insert_batch_success);
+  tjsonAddDoubleToObject(pJson, "req_insert_batch", pStat->numOfBatchInsertReqs);
+  tjsonAddDoubleToObject(pJson, "req_insert_batch_success", pStat->numOfBatchInsertSuccessReqs);
   tjsonAddDoubleToObject(pJson, "req_insert_batch_rate", req_insert_batch_rate);
-  tjsonAddDoubleToObject(pJson, "errors", pInfo->errors);
-  tjsonAddDoubleToObject(pJson, "vnodes_num", pInfo->vnodes_num);
-  tjsonAddDoubleToObject(pJson, "masters", pInfo->masters);
+  tjsonAddDoubleToObject(pJson, "errors", pStat->errors);
+  tjsonAddDoubleToObject(pJson, "vnodes_num", pStat->totalVnodes);
+  tjsonAddDoubleToObject(pJson, "masters", pStat->masterNum);
   tjsonAddDoubleToObject(pJson, "has_mnode", pInfo->has_mnode);
 }
 
-void monSetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo) {
+static void monGenDiskJson(SMonInfo *pMonitor) {
+  SMonDiskInfo *pInfo = &pMonitor->vmInfo.tfs;
+  SMonDiskDesc *pLogDesc = &pMonitor->dmInfo.dnode.logdir;
+  SMonDiskDesc *pTempDesc = &pMonitor->dmInfo.dnode.tempdir;
+
   SJson *pJson = tjsonCreateObject();
   if (pJson == NULL) return;
   if (tjsonAddItemToObject(pMonitor->pJson, "disk_infos", pJson) != 0) {
@@ -290,18 +406,18 @@ void monSetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo) {
   SJson *pLogdirJson = tjsonCreateObject();
   if (pLogdirJson == NULL) return;
   if (tjsonAddItemToObject(pJson, "logdir", pLogdirJson) != 0) return;
-  tjsonAddStringToObject(pLogdirJson, "name", pInfo->logdir.name);
-  tjsonAddDoubleToObject(pLogdirJson, "avail", pInfo->logdir.size.avail);
-  tjsonAddDoubleToObject(pLogdirJson, "used", pInfo->logdir.size.used);
-  tjsonAddDoubleToObject(pLogdirJson, "total", pInfo->logdir.size.total);
+  tjsonAddStringToObject(pLogdirJson, "name", pLogDesc->name);
+  tjsonAddDoubleToObject(pLogdirJson, "avail", pLogDesc->size.avail);
+  tjsonAddDoubleToObject(pLogdirJson, "used", pLogDesc->size.used);
+  tjsonAddDoubleToObject(pLogdirJson, "total", pLogDesc->size.total);
 
   SJson *pTempdirJson = tjsonCreateObject();
   if (pTempdirJson == NULL) return;
   if (tjsonAddItemToObject(pJson, "tempdir", pTempdirJson) != 0) return;
-  tjsonAddStringToObject(pTempdirJson, "name", pInfo->tempdir.name);
-  tjsonAddDoubleToObject(pTempdirJson, "avail", pInfo->tempdir.size.avail);
-  tjsonAddDoubleToObject(pTempdirJson, "used", pInfo->tempdir.size.used);
-  tjsonAddDoubleToObject(pTempdirJson, "total", pInfo->tempdir.size.total);
+  tjsonAddStringToObject(pTempdirJson, "name", pTempDesc->name);
+  tjsonAddDoubleToObject(pTempdirJson, "avail", pTempDesc->size.avail);
+  tjsonAddDoubleToObject(pTempdirJson, "used", pTempDesc->size.used);
+  tjsonAddDoubleToObject(pTempdirJson, "total", pTempDesc->size.total);
 }
 
 static const char *monLogLevelStr(ELogLevel level) {
@@ -319,7 +435,7 @@ static const char *monLogLevelStr(ELogLevel level) {
   }
 }
 
-static void monSetLogInfo(SMonInfo *pMonitor) {
+static void monGenLogJson(SMonInfo *pMonitor) {
   SJson *pJson = tjsonCreateObject();
   if (pJson == NULL) return;
   if (tjsonAddItemToObject(pMonitor->pJson, "log_infos", pJson) != 0) {
@@ -330,11 +446,31 @@ static void monSetLogInfo(SMonInfo *pMonitor) {
   SJson *pLogsJson = tjsonAddArrayToObject(pJson, "logs");
   if (pLogsJson == NULL) return;
 
-  for (int32_t i = 0; i < taosArrayGetSize(pMonitor->logs); ++i) {
+  SMonLogs *logs[6];
+  logs[0] = &pMonitor->logs;
+  logs[1] = &pMonitor->mmInfo.logs;
+  logs[2] = &pMonitor->vmInfo.logs;
+  logs[3] = &pMonitor->smInfo.logs;
+  logs[4] = &pMonitor->qmInfo.logs;
+  logs[5] = &pMonitor->bmInfo.logs;
+
+  int32_t numOfErrorLogs = 0;
+  int32_t numOfInfoLogs = 0;
+  int32_t numOfDebugLogs = 0;
+  int32_t numOfTraceLogs = 0;
+
+  for (int32_t j = 0; j < 6; j++) {
+    SMonLogs *pLogs = logs[j];
+    numOfErrorLogs += pLogs->numOfErrorLogs;
+    numOfInfoLogs += pLogs->numOfInfoLogs;
+    numOfDebugLogs += pLogs->numOfDebugLogs;
+    numOfTraceLogs += pLogs->numOfTraceLogs;
+
+    for (int32_t i = 0; i < taosArrayGetSize(pLogs->logs); ++i) {
       SJson *pLogJson = tjsonCreateObject();
       if (pLogJson == NULL) continue;
 
-    SMonLogItem *pLogItem = taosArrayGet(pMonitor->logs, i);
+      SMonLogItem *pLogItem = taosArrayGet(pLogs->logs, i);
 
       char buf[40] = {0};
       taosFormatUtcTime(buf, sizeof(buf), pLogItem->ts, TSDB_TIME_PRECISION_MILLI);
@@ -345,6 +481,7 @@ static void monSetLogInfo(SMonInfo *pMonitor) {
 
       if (tjsonAddItemToArray(pLogsJson, pLogJson) != 0) tjsonDelete(pLogJson);
     }
+  }
 
   SJson *pSummaryJson = tjsonAddArrayToObject(pJson, "summary");
   if (pSummaryJson == NULL) return;
@@ -352,35 +489,46 @@ static void monSetLogInfo(SMonInfo *pMonitor) {
   SJson *pLogError = tjsonCreateObject();
   if (pLogError == NULL) return;
   tjsonAddStringToObject(pLogError, "level", "error");
-  tjsonAddDoubleToObject(pLogError, "total", tsNumOfErrorLogs);
+  tjsonAddDoubleToObject(pLogError, "total", numOfErrorLogs);
   if (tjsonAddItemToArray(pSummaryJson, pLogError) != 0) tjsonDelete(pLogError);
 
   SJson *pLogInfo = tjsonCreateObject();
   if (pLogInfo == NULL) return;
   tjsonAddStringToObject(pLogInfo, "level", "info");
-  tjsonAddDoubleToObject(pLogInfo, "total", tsNumOfInfoLogs);
+  tjsonAddDoubleToObject(pLogInfo, "total", numOfInfoLogs);
   if (tjsonAddItemToArray(pSummaryJson, pLogInfo) != 0) tjsonDelete(pLogInfo);
 
   SJson *pLogDebug = tjsonCreateObject();
   if (pLogDebug == NULL) return;
   tjsonAddStringToObject(pLogDebug, "level", "debug");
-  tjsonAddDoubleToObject(pLogDebug, "total", tsNumOfDebugLogs);
+  tjsonAddDoubleToObject(pLogDebug, "total", numOfDebugLogs);
   if (tjsonAddItemToArray(pSummaryJson, pLogDebug) != 0) tjsonDelete(pLogDebug);
 
   SJson *pLogTrace = tjsonCreateObject();
   if (pLogTrace == NULL) return;
   tjsonAddStringToObject(pLogTrace, "level", "trace");
-  tjsonAddDoubleToObject(pLogTrace, "total", tsNumOfTraceLogs);
+  tjsonAddDoubleToObject(pLogTrace, "total", numOfTraceLogs);
   if (tjsonAddItemToArray(pSummaryJson, pLogTrace) != 0) tjsonDelete(pLogTrace);
 }
 
-void monSendReport(SMonInfo *pMonitor) {
-  monSetLogInfo(pMonitor);
+void monSendReport() {
+  SMonInfo *pMonitor = monCreateMonitorInfo();
+  if (pMonitor == NULL) return;
+
+  monGenBasicJson(pMonitor);
+  monGenClusterJson(pMonitor);
+  monGenVgroupJson(pMonitor);
+  monGenGrantJson(pMonitor);
+  monGenDnodeJson(pMonitor);
+  monGenDiskJson(pMonitor);
+  monGenLogJson(pMonitor);
 
   char *pCont = tjsonToString(pMonitor->pJson);
   if (pCont != NULL) {
-    EHttpCompFlag flag = tsMonitor.comp ? HTTP_GZIP : HTTP_FLAT;
-    taosSendHttpReport(tsMonitor.server, tsMonitor.port, pCont, strlen(pCont), flag);
+    EHttpCompFlag flag = tsMonitor.cfg.comp ? HTTP_GZIP : HTTP_FLAT;
+    taosSendHttpReport(tsMonitor.cfg.server, tsMonitor.cfg.port, pCont, strlen(pCont), flag);
     taosMemoryFree(pCont);
   }
+
+  monCleanupMonitorInfo(pMonitor);
 }

source/libs/monitor/test/CMakeLists.txt

 enable_testing()
 
 aux_source_directory(. MONITOR_TEST_SRC)
-add_executable(monitor_test ${MONITOR_TEST_SRC})
+add_executable(monitorTest ${MONITOR_TEST_SRC})
 target_link_libraries(
-  monitor_test
+  monitorTest
   PUBLIC monitor
   PUBLIC gtest_main
 )
 
 add_test(
-    NAME monitor_test
-    COMMAND monitor_test
+    NAME monitorTest
+    COMMAND monitorTest
 )

source/libs/monitor/test/monTest.cpp

@@ -22,7 +22,7 @@ class MonitorTest : public ::testing::Test {
     cfg.maxLogs = 2;
     cfg.port = 80;
     cfg.server = "localhost";
-    cfg.comp = 0;
+    cfg.comp = 1;
     monInit(&cfg);
   }
 
@@ -32,24 +32,64 @@ class MonitorTest : public ::testing::Test {
   void SetUp() override {}
   void TearDown() override {}
 
-  void GetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo);
-  void GetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo);
-  void GetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo);
-  void GetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo);
-  void GetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo);
-  void GetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo);
+  void GetBasicInfo(SMonBasicInfo *pInfo);
+  void GetDnodeInfo(SMonDnodeInfo *pInfo);
+  void GetSysInfo(SMonSysInfo *pInfo);
+
+  void GetClusterInfo(SMonClusterInfo *pInfo);
+  void GetVgroupInfo(SMonVgroupInfo *pInfo);
+  void GetGrantInfo(SMonGrantInfo *pInfo);
+
+  void GetVnodeStat(SVnodesStat *pStat);
+  void GetDiskInfo(SMonDiskInfo *pInfo);
+
+  void GetLogInfo(SMonLogs *logs);
+
   void AddLogInfo1();
   void AddLogInfo2();
 };
 
-void MonitorTest::GetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo) {
+void MonitorTest::GetBasicInfo(SMonBasicInfo *pInfo) {
   pInfo->dnode_id = 1;
   strcpy(pInfo->dnode_ep, "localhost");
   pInfo->cluster_id = 6980428120398645172;
   pInfo->protocol = 1;
 }
 
-void MonitorTest::GetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo) {
+void MonitorTest::GetDnodeInfo(SMonDnodeInfo *pInfo) {
+  pInfo->uptime = 1.2;
+  pInfo->has_mnode = 1;
+
+  strcpy(pInfo->logdir.name, "/log/dir/d");
+  pInfo->logdir.size.avail = 41;
+  pInfo->logdir.size.total = 42;
+  pInfo->logdir.size.used = 43;
+
+  strcpy(pInfo->tempdir.name, "/data/dir/d");
+  pInfo->tempdir.size.avail = 51;
+  pInfo->tempdir.size.total = 52;
+  pInfo->tempdir.size.used = 53;
+}
+
+void MonitorTest::GetSysInfo(SMonSysInfo *pInfo) {
+  pInfo->cpu_engine = 2.1;
+  pInfo->cpu_system = 2.1;
+  pInfo->cpu_cores = 2;
+  pInfo->mem_engine = 3.1;
+  pInfo->mem_system = 3.2;
+  pInfo->mem_total = 3.3;
+  pInfo->disk_engine = 4.1;
+  pInfo->disk_used = 4.2;
+  pInfo->disk_total = 4.3;
+  pInfo->net_in = 5.1;
+  pInfo->net_out = 5.2;
+  pInfo->io_read = 6.1;
+  pInfo->io_write = 6.2;
+  pInfo->io_read_disk = 7.1;
+  pInfo->io_write_disk = 7.2;
+}
+
+void MonitorTest::GetClusterInfo(SMonClusterInfo *pInfo) {
   strcpy(pInfo->first_ep, "localhost:6030");
   pInfo->first_ep_dnode_id = 1;
   strcpy(pInfo->version, "3.0.0.0");
@@ -86,7 +126,7 @@ void MonitorTest::GetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo) {
   taosArrayPush(pInfo->mnodes, &m2);
 }
 
-void MonitorTest::GetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo) {
+void MonitorTest::GetVgroupInfo(SMonVgroupInfo *pInfo) {
   pInfo->vgroups = taosArrayInit(4, sizeof(SMonVgroupDesc));
 
   SMonVgroupDesc vg1 = {0};
@@ -121,41 +161,24 @@ void MonitorTest::GetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo) {
   taosArrayPush(pInfo->vgroups, &vg3);
 }
 
-void MonitorTest::GetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo) {
+void MonitorTest::GetGrantInfo(SMonGrantInfo *pInfo) {
   pInfo->expire_time = 1234567;
   pInfo->timeseries_total = 234567;
   pInfo->timeseries_used = 34567;
 }
 
-void MonitorTest::GetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo) {
-  pInfo->uptime = 1.2;
-  pInfo->cpu_engine = 2.1;
-  pInfo->cpu_system = 2.1;
-  pInfo->cpu_cores = 2;
-  pInfo->mem_engine = 3.1;
-  pInfo->mem_system = 3.2;
-  pInfo->mem_total = 3.3;
-  pInfo->disk_engine = 4.1;
-  pInfo->disk_used = 4.2;
-  pInfo->disk_total = 4.3;
-  pInfo->net_in = 5.1;
-  pInfo->net_out = 5.2;
-  pInfo->io_read = 6.1;
-  pInfo->io_write = 6.2;
-  pInfo->io_read_disk = 7.1;
-  pInfo->io_write_disk = 7.2;
-  pInfo->req_select = 8;
-  pInfo->req_insert = 9;
-  pInfo->req_insert_success = 10;
-  pInfo->req_insert_batch = 11;
-  pInfo->req_insert_batch_success = 12;
+void MonitorTest::GetVnodeStat(SVnodesStat *pInfo) {
+  pInfo->numOfSelectReqs = 8;
+  pInfo->numOfInsertReqs = 9;
+  pInfo->numOfInsertSuccessReqs = 10;
+  pInfo->numOfBatchInsertReqs = 11;
+  pInfo->numOfBatchInsertSuccessReqs = 12;
   pInfo->errors = 4;
-  pInfo->vnodes_num = 5;
-  pInfo->masters = 6;
-  pInfo->has_mnode = 1;
+  pInfo->totalVnodes = 5;
+  pInfo->masterNum = 6;
 }
 
-void MonitorTest::GetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo) {
+void MonitorTest::GetDiskInfo(SMonDiskInfo *pInfo) {
   pInfo->datadirs = taosArrayInit(2, sizeof(SMonDiskDesc));
   SMonDiskDesc d1 = {0};
   strcpy(d1.name, "/t1/d1/d");
@@ -180,16 +203,25 @@ void MonitorTest::GetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo) {
   d3.size.total = 32;
   d3.size.used = 33;
   taosArrayPush(pInfo->datadirs, &d3);
+}
 
-  strcpy(pInfo->logdir.name, "/log/dir/d");
-  pInfo->logdir.size.avail = 41;
-  pInfo->logdir.size.total = 42;
-  pInfo->logdir.size.used = 43;
+void MonitorTest::GetLogInfo(SMonLogs *logs) {
+  logs->logs = taosArrayInit(4, sizeof(SMonLogItem));
 
-  strcpy(pInfo->tempdir.name, "/data/dir/d");
-  pInfo->tempdir.size.avail = 51;
-  pInfo->tempdir.size.total = 52;
-  pInfo->tempdir.size.used = 53;
+  SMonLogItem item1 = {.level = DEBUG_INFO};
+  item1.ts = taosGetTimestampMs();
+  strcpy(item1.content, "log test1");
+  taosArrayPush(logs->logs, &item1);
+
+  SMonLogItem item2 = {.level = DEBUG_ERROR};
+  item2.ts = taosGetTimestampMs();
+  strcpy(item2.content, "log test2");
+  taosArrayPush(logs->logs, &item2);
+
+  logs->numOfErrorLogs = 1;
+  logs->numOfInfoLogs = 2;
+  logs->numOfDebugLogs = 3;
+  logs->numOfTraceLogs = 4;
 }
 
 void MonitorTest::AddLogInfo1() {
@@ -206,46 +238,52 @@ void MonitorTest::AddLogInfo2() {
 TEST_F(MonitorTest, 01_Full) {
   AddLogInfo1();
 
-  SMonInfo *pMonitor = monCreateMonitorInfo();
-  if (pMonitor == NULL) return;
-
-  SMonBasicInfo basicInfo = {0};
-  GetBasicInfo(pMonitor, &basicInfo);
-  monSetBasicInfo(pMonitor, &basicInfo);
-
-  SMonClusterInfo clusterInfo = {0};
-  SMonVgroupInfo  vgroupInfo = {0};
-  SMonGrantInfo   grantInfo = {0};
-  GetClusterInfo(pMonitor, &clusterInfo);
-  GetVgroupInfo(pMonitor, &vgroupInfo);
-  GetGrantInfo(pMonitor, &grantInfo);
-  monSetClusterInfo(pMonitor, &clusterInfo);
-  monSetVgroupInfo(pMonitor, &vgroupInfo);
-  monSetGrantInfo(pMonitor, &grantInfo);
-
-  SMonDnodeInfo dnodeInfo = {0};
-  GetDnodeInfo(pMonitor, &dnodeInfo);
-  monSetDnodeInfo(pMonitor, &dnodeInfo);
-
-  SMonDiskInfo diskInfo = {0};
-  GetDiskInfo(pMonitor, &diskInfo);
-  monSetDiskInfo(pMonitor, &diskInfo);
-
-  monSendReport(pMonitor);
-  monCleanupMonitorInfo(pMonitor);
-
-  taosArrayDestroy(clusterInfo.dnodes);
-  taosArrayDestroy(clusterInfo.mnodes);
-  taosArrayDestroy(vgroupInfo.vgroups);
-  taosArrayDestroy(diskInfo.datadirs);
+  SMonDmInfo dmInfo = {0};
+  GetBasicInfo(&dmInfo.basic);
+  GetDnodeInfo(&dmInfo.dnode);
+  GetSysInfo(&dmInfo.sys);
+
+  SMonMmInfo mmInfo = {0};
+  GetClusterInfo(&mmInfo.cluster);
+  GetVgroupInfo(&mmInfo.vgroup);
+  GetGrantInfo(&mmInfo.grant);
+  GetSysInfo(&mmInfo.sys);
+  GetLogInfo(&mmInfo.logs);
+
+  SMonVmInfo vmInfo = {0};
+  GetDiskInfo(&vmInfo.tfs);
+  GetVnodeStat(&vmInfo.vstat);
+  GetSysInfo(&vmInfo.sys);
+  GetLogInfo(&vmInfo.logs);
+
+  SMonQmInfo qmInfo = {0};
+  GetSysInfo(&qmInfo.sys);
+  GetLogInfo(&qmInfo.logs);
+
+  SMonSmInfo smInfo = {0};
+  GetSysInfo(&smInfo.sys);
+  GetLogInfo(&smInfo.logs);
+
+  SMonBmInfo bmInfo = {0};
+  GetSysInfo(&bmInfo.sys);
+  GetLogInfo(&bmInfo.logs);
+
+  monSetDmInfo(&dmInfo);
+  monSetMmInfo(&mmInfo);
+  monSetVmInfo(&vmInfo);
+  monSetQmInfo(&qmInfo);
+  monSetSmInfo(&smInfo);
+  monSetBmInfo(&bmInfo);
+
+  tFreeSMonMmInfo(&mmInfo);
+  tFreeSMonVmInfo(&vmInfo);
+  tFreeSMonSmInfo(&smInfo);
+  tFreeSMonQmInfo(&qmInfo);
+  tFreeSMonBmInfo(&bmInfo);
+  monSendReport();
 }
 
 TEST_F(MonitorTest, 02_Log) {
   AddLogInfo2();
-
-  SMonInfo *pMonitor = monCreateMonitorInfo();
-  if (pMonitor == NULL) return;
-
-  monSendReport(pMonitor);
-  monCleanupMonitorInfo(pMonitor);
+  monSendReport();
 }

source/os/src/osSysinfo.c

@@ -129,14 +129,12 @@ static void taosGetProcIOnfos() {
 static int32_t taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
   TdFilePtr pFile = taosOpenFile(tsSysCpuFile, TD_FILE_READ | TD_FILE_STREAM);
   if (pFile == NULL) {
-    // printf("open file:%s failed", tsSysCpuFile);
     return -1;
   }
 
   char   *line = NULL;
   ssize_t _bytes = taosGetLineFile(pFile, &line);
   if ((_bytes < 0) || (line == NULL)) {
-    // printf("read file:%s failed", tsSysCpuFile);
     taosCloseFile(&pFile);
     return -1;
   }
@@ -153,14 +151,12 @@ static int32_t taosGetSysCpuInfo(SysCpuInfo *cpuInfo) {
 static int32_t taosGetProcCpuInfo(ProcCpuInfo *cpuInfo) {
   TdFilePtr pFile = taosOpenFile(tsProcCpuFile, TD_FILE_READ | TD_FILE_STREAM);
   if (pFile == NULL) {
-    // printf("open file:%s failed", tsProcCpuFile);
     return -1;
   }
 
   char   *line = NULL;
   ssize_t _bytes = taosGetLineFile(pFile, &line);
   if ((_bytes < 0) || (line == NULL)) {
-    // printf("read file:%s failed", tsProcCpuFile);
     taosCloseFile(&pFile);
     return -1;
   }
@@ -182,12 +178,12 @@ static int32_t taosGetProcCpuInfo(ProcCpuInfo *cpuInfo) {
 #endif
 
 bool taosCheckSystemIsSmallEnd() {
-    union check{
+  union check {
     int16_t i;
     char    ch[2];
-    }c;
-    c.i=1;
-    return c.ch[0]==1;
+  } c;
+  c.i = 1;
+  return c.ch[0] == 1;
 }
 
 void taosGetSystemInfo() {
@@ -617,6 +613,28 @@ int32_t taosGetProcIO(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int
 #endif
 }
 
+void taosGetProcIODelta(int64_t *rchars, int64_t *wchars, int64_t *read_bytes, int64_t *write_bytes) {
+  static int64_t last_rchars = 0;
+  static int64_t last_wchars = 0;
+  static int64_t last_read_bytes = 0;
+  static int64_t last_write_bytes = 0;
+
+  static int64_t cur_rchars = 0;
+  static int64_t cur_wchars = 0;
+  static int64_t cur_read_bytes = 0;
+  static int64_t cur_write_bytes = 0;
+  if (taosGetProcIO(&cur_rchars, &cur_wchars, &cur_read_bytes, &cur_write_bytes) != 0) {
+    *rchars = cur_rchars - last_rchars;
+    *wchars = cur_wchars - last_wchars;
+    *read_bytes = cur_read_bytes - last_read_bytes;
+    *write_bytes = cur_write_bytes - last_write_bytes;
+    last_rchars = cur_rchars;
+    last_wchars = cur_wchars;
+    last_read_bytes = cur_read_bytes;
+    last_write_bytes = cur_write_bytes;
+  }
+}
+
 int32_t taosGetCardInfo(int64_t *receive_bytes, int64_t *transmit_bytes) {
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
   *receive_bytes = 0;
@@ -672,6 +690,20 @@ int32_t taosGetCardInfo(int64_t *receive_bytes, int64_t *transmit_bytes) {
 #endif
 }
 
+void taosGetCardInfoDelta(int64_t *receive_bytes, int64_t *transmit_bytes) {
+  static int64_t last_receive_bytes = 0;
+  static int64_t last_transmit_bytes = 0;
+
+  static int64_t cur_receive_bytes = 0;
+  static int64_t cur_transmit_bytes = 0;
+  if (taosGetCardInfo(&cur_receive_bytes, &cur_transmit_bytes) != 0) {
+    *receive_bytes = cur_receive_bytes - last_receive_bytes;
+    *transmit_bytes = cur_transmit_bytes - last_transmit_bytes;
+    last_receive_bytes = cur_receive_bytes;
+    last_transmit_bytes = cur_transmit_bytes;
+  }
+}
+
 void taosKillSystem() {
 #if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
   printf("function taosKillSystem, exit!");