xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat: send monitor information in multi-process mode

This commit is contained in:
Shengliang Guan 2022-04-07 19:06:01 +08:00
parent 1844645403
commit f492ae743a
14 changed files with 649 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/common/tmsg.h
View File

@ -679,6 +679,18 @@ typedef struct {
char charset[TD_LOCALE_LEN]; // tsCharset char charset[TD_LOCALE_LEN]; // tsCharset
} SClusterCfg; } 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 { typedef struct {
int32_t vgId; int32_t vgId;
int8_t role; int8_t role;

9
include/common/tmsgdef.h
View File

@ -216,6 +216,15 @@ enum {
TD_NEW_MSG_SEG(TDMT_SCH_MSG) TD_NEW_MSG_SEG(TDMT_SCH_MSG)
TD_DEF_MSG_TYPE(TDMT_SCH_LINK_BROKEN, "scheduler-link-broken", NULL, NULL) 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_) #if defined(TD_MSG_NUMBER_)
TDMT_MAX TDMT_MAX
#endif #endif

153
include/libs/monitor/monitor.h
View File

@ -19,6 +19,7 @@
#include "tarray.h" #include "tarray.h"
#include "tdef.h" #include "tdef.h"
#include "tlog.h" #include "tlog.h"
#include "tmsg.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -29,6 +30,44 @@ extern "C" {
#define MON_VER_LEN 12 #define MON_VER_LEN 12
#define MON_LOG_LEN 1024 #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 { typedef struct {
int32_t dnode_id; int32_t dnode_id;
char dnode_ep[TSDB_EP_LEN]; char dnode_ep[TSDB_EP_LEN];
@ -36,6 +75,19 @@ typedef struct {
int32_t protocol; int32_t protocol;
} SMonBasicInfo; } 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 { typedef struct {
int32_t dnode_id; int32_t dnode_id;
char dnode_ep[TSDB_EP_LEN]; char dnode_ep[TSDB_EP_LEN];
@ -87,46 +139,57 @@ typedef struct {
} SMonGrantInfo; } SMonGrantInfo;
typedef struct { typedef struct {
float uptime; // day SMonClusterInfo cluster;
double cpu_engine; SMonVgroupInfo vgroup;
double cpu_system; SMonGrantInfo grant;
float cpu_cores; SMonSysInfo sys;
int64_t mem_engine; // KB SMonLogs logs;
int64_t mem_system; // KB } SMonMmInfo;
int64_t mem_total; // KB
int64_t disk_engine; // Byte int32_t tSerializeSMonMmInfo(void *buf, int32_t bufLen, SMonMmInfo *pInfo);
int64_t disk_used; // Byte int32_t tDeserializeSMonMmInfo(void *buf, int32_t bufLen, SMonMmInfo *pInfo);
int64_t disk_total; // Byte void tFreeSMonMmInfo(SMonMmInfo *pInfo);
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;
typedef struct { typedef struct {
char name[TSDB_FILENAME_LEN]; SArray *datadirs; // array of SMonDiskDesc
int8_t level;
SDiskSize size;
} SMonDiskDesc;
typedef struct {
SArray *datadirs; // array of SMonDiskDesc
SMonDiskDesc logdir;
SMonDiskDesc tempdir;
} SMonDiskInfo; } 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 { typedef struct {
const char *server; const char *server;
@ -138,16 +201,14 @@ typedef struct {
int32_t monInit(const SMonCfg *pCfg); int32_t monInit(const SMonCfg *pCfg);
void monCleanup(); void monCleanup();
void monRecordLog(int64_t ts, ELogLevel level, const char *content); void monRecordLog(int64_t ts, ELogLevel level, const char *content);
int32_t monGetLogs(SMonLogs *logs);
SMonInfo *monCreateMonitorInfo(); void monSetDmInfo(SMonDmInfo *pInfo);
void monSetBasicInfo(SMonInfo *pMonitor, SMonBasicInfo *pInfo); void monSetMmInfo(SMonMmInfo *pInfo);
void monSetClusterInfo(SMonInfo *pMonitor, SMonClusterInfo *pInfo); void monSetVmInfo(SMonVmInfo *pInfo);
void monSetVgroupInfo(SMonInfo *pMonitor, SMonVgroupInfo *pInfo); void monSetQmInfo(SMonQmInfo *pInfo);
void monSetGrantInfo(SMonInfo *pMonitor, SMonGrantInfo *pInfo); void monSetSmInfo(SMonSmInfo *pInfo);
void monSetDnodeInfo(SMonInfo *pMonitor, SMonDnodeInfo *pInfo); void monSetBmInfo(SMonBmInfo *pInfo);
void monSetDiskInfo(SMonInfo *pMonitor, SMonDiskInfo *pInfo); void monSendReport();
void monSendReport(SMonInfo *pMonitor);
void monCleanupMonitorInfo(SMonInfo *pMonitor);
#ifdef __cplusplus #ifdef __cplusplus
} }

4
include/os/osSysinfo.h
View File

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

3
source/dnode/mgmt/dm/dmHandle.c
View File

@ -212,4 +212,7 @@ void dmInitMsgHandle(SMgmtWrapper *pWrapper) {
dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, dmProcessStatusMsg, DEFAULT_HANDLE); dndSetMsgHandle(pWrapper, TDMT_MND_STATUS_RSP, dmProcessStatusMsg, DEFAULT_HANDLE);
dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE); dndSetMsgHandle(pWrapper, TDMT_MND_GRANT_RSP, dmProcessMgmtMsg, DEFAULT_HANDLE);
dndSetMsgHandle(pWrapper, TDMT_MND_AUTH_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);
} }

34
source/dnode/mgmt/dm/dmMonitor.c
View File

@ -14,7 +14,7 @@
*/ */
#define _DEFAULT_SOURCE #define _DEFAULT_SOURCE
#include "dndInt.h" #include "dmInt.h"
static int32_t dmGetMonitorDiskInfo(SDnode *pDnode, SMonDiskInfo *pInfo) { static int32_t dmGetMonitorDiskInfo(SDnode *pDnode, SMonDiskInfo *pInfo) {
tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name)); tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));
@ -104,4 +104,36 @@ void dmSendMonitorReport(SDnode *pDnode) {
monSendReport(pMonitor); monSendReport(pMonitor);
monCleanupMonitorInfo(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;
} }

3
source/dnode/mgmt/dm/dmWorker.c
View File

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

10
source/dnode/mgmt/inc/dmInt.h
View File

@ -37,6 +37,11 @@ typedef struct SDnodeMgmt {
const char *path; const char *path;
SDnode *pDnode; SDnode *pDnode;
SMgmtWrapper *pWrapper; SMgmtWrapper *pWrapper;
// monitor infos
SMonDiskInfo diskInfo;
SMonVnodesStat vnodesStat;
SMonVnodesLoad vnodesLoad;
} SDnodeMgmt; } SDnodeMgmt;
// dmFile.c // dmFile.c
@ -54,7 +59,10 @@ int32_t dmProcessGrantRsp(SDnodeMgmt *pMgmt, SNodeMsg *pMsg);
int32_t dmProcessCDnodeReq(SDnode *pDnode, SNodeMsg *pMsg); int32_t dmProcessCDnodeReq(SDnode *pDnode, SNodeMsg *pMsg);
// dmMonitor.c // dmMonitor.c
void dmSendMonitorReport(SDnode *pDnode); 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 // dmWorker.c
int32_t dmStartThread(SDnodeMgmt *pMgmt); int32_t dmStartThread(SDnodeMgmt *pMgmt);

49
source/libs/monitor/inc/monInt.h
View File

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

54
source/libs/monitor/src/monMsg.c Normal file
View File

@ -0,0 +1,54 @@
/*
* 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;
}

326
source/libs/monitor/src/monitor.c
View File

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

8
source/libs/monitor/test/CMakeLists.txt
View File

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

192
source/libs/monitor/test/monTest.cpp
View File

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

52
source/os/src/osSysinfo.c
View File

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