#4788

Committed 14 Oct 2025 11:21AM UTC coverage: 60.992% (-2.3%) from 63.264%

Build # #4788

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge 7ca9b50f9 into 19574fe21

Run Details

154868 of 324306 branches covered (47.75%)

Branch coverage included in aggregate %.

207304 of 269498 relevant lines covered (76.92%)

125773493.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

56.9

/source/dnode/mgmt/node_mgmt/src/dmMonitor.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 "dmMgmt.h"
#include "dmNodes.h"
#include "audit.h"

static void dmGetMonitorBasicInfo(SDnode *pDnode, SMonBasicInfo *pInfo) {
  pInfo->protocol = 1;
  pInfo->dnode_id = pDnode->data.dnodeId;
  pInfo->cluster_id = pDnode->data.clusterId;
  tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);
}

static void dmGetMonitorBasicInfoBasic(SDnode *pDnode, SMonBasicInfo *pInfo) {
  pInfo->protocol = 2;
  pInfo->dnode_id = pDnode->data.dnodeId;
  pInfo->cluster_id = pDnode->data.clusterId;
  tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);
}

static void dmGetMonitorDnodeInfo(SDnode *pDnode, SMonDnodeInfo *pInfo) {
  // pInfo->uptime = (taosGetTimestampMs() - pDnode->data.rebootTime) / (86400000.0f);
  pInfo->uptime = (taosGetTimestampMs() - pDnode->data.rebootTime) / 1000.0f;
  pInfo->has_mnode = pDnode->wrappers[MNODE].required;
  pInfo->has_qnode = pDnode->wrappers[QNODE].required;
  pInfo->has_snode = pDnode->wrappers[SNODE].required;
  tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));
  pInfo->logdir.size = tsLogSpace.size;
  tstrncpy(pInfo->tempdir.name, tsTempDir, sizeof(pInfo->tempdir.name));
  pInfo->tempdir.size = tsTempSpace.size;
}

static void dmGetDmMonitorInfo(SDnode *pDnode) {
  SMonDmInfo dmInfo = {0};
  dmGetMonitorBasicInfo(pDnode, &dmInfo.basic);
  dmGetMonitorDnodeInfo(pDnode, &dmInfo.dnode);
  dmGetMonitorSystemInfo(&dmInfo.sys);
  monSetDmInfo(&dmInfo);
}

void dmCleanExpriedSamples(SDnode *pDnode) {
  SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      vmCleanExpriedSamples(pWrapper->pMgmt);
    }
  }
  dmReleaseWrapper(pWrapper);
  return;
}

static void dmGetDmMonitorInfoBasic(SDnode *pDnode) {
  SMonDmInfo dmInfo = {0};
  dmGetMonitorBasicInfoBasic(pDnode, &dmInfo.basic);
  monSetDmInfo(&dmInfo);
}

static void dmGetMmMonitorInfo(SDnode *pDnode) {
  SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    SMonMmInfo mmInfo = {0};
    if (pWrapper->pMgmt != NULL) {
      mmGetMonitorInfo(pWrapper->pMgmt, &mmInfo);
    }
    dmReleaseWrapper(pWrapper);
    monSetMmInfo(&mmInfo);
    tFreeSMonMmInfo(&mmInfo);
  }
}

static void dmGetVmMonitorInfo(SDnode *pDnode) {
  SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    SMonVmInfo vmInfo = {0};
    if (pWrapper->pMgmt != NULL) {
      vmGetMonitorInfo(pWrapper->pMgmt, &vmInfo);
    }
    dmReleaseWrapper(pWrapper);
    monSetVmInfo(&vmInfo);
    tFreeSMonVmInfo(&vmInfo);
  }
}

static void dmGetQmMonitorInfo(SDnode *pDnode) {
  SMgmtWrapper *pWrapper = &pDnode->wrappers[QNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    SMonQmInfo qmInfo = {0};
    if (pWrapper->pMgmt != NULL) {
      qmGetMonitorInfo(pWrapper->pMgmt, &qmInfo);
    }
    dmReleaseWrapper(pWrapper);
    monSetQmInfo(&qmInfo);
    tFreeSMonQmInfo(&qmInfo);
  }
}

static void dmGetSmMonitorInfo(SDnode *pDnode) {
  SMgmtWrapper *pWrapper = &pDnode->wrappers[SNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    SMonSmInfo smInfo = {0};
    if (pWrapper->pMgmt != NULL) {
      smGetMonitorInfo(pWrapper->pMgmt, &smInfo);
    }
    dmReleaseWrapper(pWrapper);
    monSetSmInfo(&smInfo);
    tFreeSMonSmInfo(&smInfo);
  }
}

void dmSendMonitorReport() {
  if (!tsEnableMonitor || tsMonitorFqdn[0] == 0 || tsMonitorPort == 0) return;
  dTrace("send monitor report to %s:%u", tsMonitorFqdn, tsMonitorPort);

  SDnode *pDnode = dmInstance();
  dmGetDmMonitorInfo(pDnode);
  dmGetMmMonitorInfo(pDnode);
  dmGetVmMonitorInfo(pDnode);
  dmGetQmMonitorInfo(pDnode);
  dmGetSmMonitorInfo(pDnode);
  monGenAndSendReport();
}

void dmMonitorCleanExpiredSamples() {
  if (!tsEnableMonitor || tsMonitorFqdn[0] == 0 || tsMonitorPort == 0) return;
  dTrace("clean monitor expired samples");

  SDnode *pDnode = dmInstance();
  (void)dmCleanExpriedSamples(pDnode);
}

// Todo: put this in seperate file in the future
void dmSendAuditRecords() { auditSendRecordsInBatch(); }

void dmGetVnodeLoads(SMonVloadInfo *pInfo) {
  SDnode       *pDnode = dmInstance();
  SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      vmGetVnodeLoads(pWrapper->pMgmt, pInfo, false);
    }
    dmReleaseWrapper(pWrapper);
  }
}

void dmGetVnodeLoadsLite(SMonVloadInfo *pInfo) {
  SDnode       *pDnode = dmInstance();
  SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      vmGetVnodeLoadsLite(pWrapper->pMgmt, pInfo);
    }
    dmReleaseWrapper(pWrapper);
  }
}

void dmGetMnodeLoads(SMonMloadInfo *pInfo) {
  SDnode       *pDnode = dmInstance();
  SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      mmGetMnodeLoads(pWrapper->pMgmt, pInfo);
    }
    dmReleaseWrapper(pWrapper);
  }
}

void dmSetMnodeSyncTimeout() {
  dInfo("dmSetMnodeSyncTimeout");
  SDnode       *pDnode = dmInstance();
  SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      mmSetMnodeSyncTimeout(pWrapper->pMgmt);
    }
    dmReleaseWrapper(pWrapper);
  }
}

void dmSetVnodeSyncTimeout() {
  dInfo("dmSetVnodeSyncTimeout");
  SDnode       *pDnode = dmInstance();
  SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      vmSetVnodeSyncTimeout(pWrapper->pMgmt);
    }
    dmReleaseWrapper(pWrapper);
  }
}

void dmGetQnodeLoads(SQnodeLoad *pInfo) {
  SDnode       *pDnode = dmInstance();
  SMgmtWrapper *pWrapper = &pDnode->wrappers[QNODE];
  if (dmMarkWrapper(pWrapper) == 0) {
    if (pWrapper->pMgmt != NULL) {
      qmGetQnodeLoads(pWrapper->pMgmt, pInfo);
    }
    dmReleaseWrapper(pWrapper);
  }
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#define _DEFAULT_SOURCE
17	#include "dmMgmt.h"
18	#include "dmNodes.h"
19	#include "audit.h"
20
21	static void dmGetMonitorBasicInfo(SDnode pDnode, SMonBasicInfo pInfo) {	173✔
22	pInfo->protocol = 1;	173✔
23	pInfo->dnode_id = pDnode->data.dnodeId;	173✔
24	pInfo->cluster_id = pDnode->data.clusterId;	173✔
25	tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);	173!
26	}	173✔
27
28	static void dmGetMonitorBasicInfoBasic(SDnode pDnode, SMonBasicInfo pInfo) {	×
29	pInfo->protocol = 2;	×
30	pInfo->dnode_id = pDnode->data.dnodeId;	×
31	pInfo->cluster_id = pDnode->data.clusterId;	×
32	tstrncpy(pInfo->dnode_ep, tsLocalEp, TSDB_EP_LEN);	×
33	}	×
34
35	static void dmGetMonitorDnodeInfo(SDnode pDnode, SMonDnodeInfo pInfo) {	173✔
36	// pInfo->uptime = (taosGetTimestampMs() - pDnode->data.rebootTime) / (86400000.0f);
37	pInfo->uptime = (taosGetTimestampMs() - pDnode->data.rebootTime) / 1000.0f;	173!
38	pInfo->has_mnode = pDnode->wrappers[MNODE].required;	173!
39	pInfo->has_qnode = pDnode->wrappers[QNODE].required;	173!
40	pInfo->has_snode = pDnode->wrappers[SNODE].required;	173!
41	tstrncpy(pInfo->logdir.name, tsLogDir, sizeof(pInfo->logdir.name));	173!
42	pInfo->logdir.size = tsLogSpace.size;	173✔
43	tstrncpy(pInfo->tempdir.name, tsTempDir, sizeof(pInfo->tempdir.name));	173!
44	pInfo->tempdir.size = tsTempSpace.size;	173✔
45	}	173✔
46
47	static void dmGetDmMonitorInfo(SDnode *pDnode) {	173✔
48	SMonDmInfo dmInfo = {0};	173✔
49	dmGetMonitorBasicInfo(pDnode, &dmInfo.basic);	173✔
50	dmGetMonitorDnodeInfo(pDnode, &dmInfo.dnode);	173✔
51	dmGetMonitorSystemInfo(&dmInfo.sys);	173✔
52	monSetDmInfo(&dmInfo);	173✔
53	}	173✔
54
55	void dmCleanExpriedSamples(SDnode *pDnode) {	173✔
56	SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];	173✔
57	if (dmMarkWrapper(pWrapper) == 0) {	173!
58	if (pWrapper->pMgmt != NULL) {	173!
59	vmCleanExpriedSamples(pWrapper->pMgmt);	173✔
60	}
61	}
62	dmReleaseWrapper(pWrapper);	173✔
63	return;	173✔
64	}
65
66	static void dmGetDmMonitorInfoBasic(SDnode *pDnode) {	×
67	SMonDmInfo dmInfo = {0};	×
68	dmGetMonitorBasicInfoBasic(pDnode, &dmInfo.basic);	×
69	monSetDmInfo(&dmInfo);	×
70	}	×
71
72	static void dmGetMmMonitorInfo(SDnode *pDnode) {	173✔
73	SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];	173✔
74	if (dmMarkWrapper(pWrapper) == 0) {	173!
75	SMonMmInfo mmInfo = {0};	173✔
76	if (pWrapper->pMgmt != NULL) {	173!
77	mmGetMonitorInfo(pWrapper->pMgmt, &mmInfo);	173✔
78	}
79	dmReleaseWrapper(pWrapper);	173✔
80	monSetMmInfo(&mmInfo);	173✔
81	tFreeSMonMmInfo(&mmInfo);	173✔
82	}
83	}	173✔
84
85	static void dmGetVmMonitorInfo(SDnode *pDnode) {	173✔
86	SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];	173✔
87	if (dmMarkWrapper(pWrapper) == 0) {	173!
88	SMonVmInfo vmInfo = {0};	173✔
89	if (pWrapper->pMgmt != NULL) {	173!
90	vmGetMonitorInfo(pWrapper->pMgmt, &vmInfo);	173✔
91	}
92	dmReleaseWrapper(pWrapper);	173✔
93	monSetVmInfo(&vmInfo);	173✔
94	tFreeSMonVmInfo(&vmInfo);	173✔
95	}
96	}	173✔
97
98	static void dmGetQmMonitorInfo(SDnode *pDnode) {	173✔
99	SMgmtWrapper *pWrapper = &pDnode->wrappers[QNODE];	173✔
100	if (dmMarkWrapper(pWrapper) == 0) {	173!
101	SMonQmInfo qmInfo = {0};	×
102	if (pWrapper->pMgmt != NULL) {	×
103	qmGetMonitorInfo(pWrapper->pMgmt, &qmInfo);	×
104	}
105	dmReleaseWrapper(pWrapper);	×
106	monSetQmInfo(&qmInfo);	×
107	tFreeSMonQmInfo(&qmInfo);	×
108	}
109	}	173✔
110
111	static void dmGetSmMonitorInfo(SDnode *pDnode) {	173✔
112	SMgmtWrapper *pWrapper = &pDnode->wrappers[SNODE];	173✔
113	if (dmMarkWrapper(pWrapper) == 0) {	173!
114	SMonSmInfo smInfo = {0};	×
115	if (pWrapper->pMgmt != NULL) {	×
116	smGetMonitorInfo(pWrapper->pMgmt, &smInfo);	×
117	}
118	dmReleaseWrapper(pWrapper);	×
119	monSetSmInfo(&smInfo);	×
120	tFreeSMonSmInfo(&smInfo);	×
121	}
122	}	173✔
123
124	void dmSendMonitorReport() {	1,033,201✔
125	if (!tsEnableMonitor \|\| tsMonitorFqdn[0] == 0 \|\| tsMonitorPort == 0) return;	1,033,201!
126	dTrace("send monitor report to %s:%u", tsMonitorFqdn, tsMonitorPort);	173!
127
128	SDnode *pDnode = dmInstance();	173✔
129	dmGetDmMonitorInfo(pDnode);	173✔
130	dmGetMmMonitorInfo(pDnode);	173✔
131	dmGetVmMonitorInfo(pDnode);	173✔
132	dmGetQmMonitorInfo(pDnode);	173✔
133	dmGetSmMonitorInfo(pDnode);	173✔
134	monGenAndSendReport();	173✔
135	}
136
137	void dmMonitorCleanExpiredSamples() {	1,033,201✔
138	if (!tsEnableMonitor \|\| tsMonitorFqdn[0] == 0 \|\| tsMonitorPort == 0) return;	1,033,201!
139	dTrace("clean monitor expired samples");	173!
140
141	SDnode *pDnode = dmInstance();	173✔
142	(void)dmCleanExpriedSamples(pDnode);	173✔
143	}
144
145	// Todo: put this in seperate file in the future
146	void dmSendAuditRecords() { auditSendRecordsInBatch(); }	×
147
148	void dmGetVnodeLoads(SMonVloadInfo *pInfo) {	38,765,905✔
149	SDnode *pDnode = dmInstance();	38,765,905✔
150	SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];	38,765,905✔
151	if (dmMarkWrapper(pWrapper) == 0) {	38,765,905✔
152	if (pWrapper->pMgmt != NULL) {	38,733,231!
153	vmGetVnodeLoads(pWrapper->pMgmt, pInfo, false);	38,733,231✔
154	}
155	dmReleaseWrapper(pWrapper);	38,733,231✔
156	}
157	}	38,765,905✔
158
159	void dmGetVnodeLoadsLite(SMonVloadInfo *pInfo) {	×
160	SDnode *pDnode = dmInstance();	×
161	SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];	×
162	if (dmMarkWrapper(pWrapper) == 0) {	×
163	if (pWrapper->pMgmt != NULL) {	×
164	vmGetVnodeLoadsLite(pWrapper->pMgmt, pInfo);	×
165	}
166	dmReleaseWrapper(pWrapper);	×
167	}
168	}	×
169
170	void dmGetMnodeLoads(SMonMloadInfo *pInfo) {	38,765,905✔
171	SDnode *pDnode = dmInstance();	38,765,905✔
172	SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];	38,765,905✔
173	if (dmMarkWrapper(pWrapper) == 0) {	38,765,905✔
174	if (pWrapper->pMgmt != NULL) {	23,679,038!
175	mmGetMnodeLoads(pWrapper->pMgmt, pInfo);	23,679,038✔
176	}
177	dmReleaseWrapper(pWrapper);	23,679,038✔
178	}
179	}	38,765,905✔
180
181	void dmSetMnodeSyncTimeout() {	×
182	dInfo("dmSetMnodeSyncTimeout");	×
183	SDnode *pDnode = dmInstance();	×
184	SMgmtWrapper *pWrapper = &pDnode->wrappers[MNODE];	×
185	if (dmMarkWrapper(pWrapper) == 0) {	×
186	if (pWrapper->pMgmt != NULL) {	×
187	mmSetMnodeSyncTimeout(pWrapper->pMgmt);	×
188	}
189	dmReleaseWrapper(pWrapper);	×
190	}
191	}	×
192
193	void dmSetVnodeSyncTimeout() {	×
194	dInfo("dmSetVnodeSyncTimeout");	×
195	SDnode *pDnode = dmInstance();	×
196	SMgmtWrapper *pWrapper = &pDnode->wrappers[VNODE];	×
197	if (dmMarkWrapper(pWrapper) == 0) {	×
198	if (pWrapper->pMgmt != NULL) {	×
199	vmSetVnodeSyncTimeout(pWrapper->pMgmt);	×
200	}
201	dmReleaseWrapper(pWrapper);	×
202	}
203	}	×
204
205	void dmGetQnodeLoads(SQnodeLoad *pInfo) {	38,194,103✔
206	SDnode *pDnode = dmInstance();	38,194,103✔
207	SMgmtWrapper *pWrapper = &pDnode->wrappers[QNODE];	38,194,103✔
208	if (dmMarkWrapper(pWrapper) == 0) {	38,194,103✔
209	if (pWrapper->pMgmt != NULL) {	107,731!
210	qmGetQnodeLoads(pWrapper->pMgmt, pInfo);	107,731✔
211	}
212	dmReleaseWrapper(pWrapper);	107,731✔
213	}
214	}	38,194,103✔

taosdata / TDengine / #4788

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous