@cryptotaxi247 / netdata-1 / commits / 379a099d0

Cleanup win plugin (Remove MSSQL) (#21876)

thiagoftsm committed Mar 5, 2026 at 12:19 UTC 379a099d08d87375591cff2992362607e30965fd
7 files changed +2 -4994
CMakeLists.txt
-3
@@ -2000,20 +2000,17 @@ set(WINDOWS_PLUGIN_FILES
2000 src/collectors/windows.plugin/GetServicesStatus.c
2001 src/collectors/windows.plugin/GetSensors.c
2002 src/collectors/windows.plugin/GetHardwareInfo.c
2003 - src/collectors/windows.plugin/MonitorSQL.c
2003 src/collectors/windows.plugin/perflib-adcs.c
2004 src/collectors/windows.plugin/perflib-adfs.c
2005 src/collectors/windows.plugin/perflib-rrd.c
2006 src/collectors/windows.plugin/perflib-rrd.h
2007 src/collectors/windows.plugin/perflib-ad.c
2009 - src/collectors/windows.plugin/perflib-mssql-queries.h
2008 src/collectors/windows.plugin/perflib-storage.c
2009 src/collectors/windows.plugin/perflib-processor.c
2010 src/collectors/windows.plugin/perflib-thermalzone.c
2011 src/collectors/windows.plugin/perflib-objects.c
2012 src/collectors/windows.plugin/perflib-network.c
2013 src/collectors/windows.plugin/perflib-netframework.c
2016 - src/collectors/windows.plugin/perflib-mssql.c
2014 src/collectors/windows.plugin/perflib-memory.c
2015 src/collectors/windows.plugin/perflib-processes.c
2016 src/collectors/windows.plugin/perflib-web-service.c
src/collectors/windows.plugin/MonitorSQL.c deleted
-3300
@@ -1,3300 +0,0 @@
1 -// SPDX-License-Identifier: GPL-3.0-or-later
2 -
3 -#include "windows_plugin.h"
4 -#include "windows-internals.h"
5 -
6 -#include "perflib-mssql-queries.h"
7 -
8 -DICTIONARY *conn_options;
9 -
10 -static inline bool netdata_mssql_check_result(SQLRETURN ret)
11 -{
12 - return (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO);
13 -}
14 -
15 -static char *netdata_MSSQL_error_text(enum netdata_mssql_odbc_errors val)
16 -{
17 - switch (val) {
18 - case NETDATA_MSSQL_ODBC_NO_ERROR:
19 - return "NO ERROR";
20 - case NETDATA_MSSQL_ODBC_CONNECT:
21 - return "CONNECTION";
22 - case NETDATA_MSSQL_ODBC_BIND:
23 - return "BIND PARAMETER";
24 - case NETDATA_MSSQL_ODBC_PREPARE:
25 - return "PREPARE PARAMETER";
26 - case NETDATA_MSSQL_ODBC_QUERY:
27 - return "QUERY PARAMETER";
28 - case NETDATA_MSSQL_ODBC_FETCH:
29 - default:
30 - return "QUERY FETCH";
31 - }
32 -}
33 -
34 -static char *netdata_MSSQL_type_text(uint32_t type)
35 -{
36 - switch (type) {
37 - case SQL_HANDLE_STMT:
38 - return "STMT";
39 - case SQL_HANDLE_DBC:
40 - default:
41 - return "DBC";
42 - }
43 -}
44 -
45 -// Connection and SQL
46 -static void netdata_MSSQL_error(uint32_t type, SQLHANDLE handle, enum netdata_mssql_odbc_errors step, char *instance)
47 -{
48 - SQLCHAR state[1024];
49 - SQLCHAR message[1024];
50 - if (likely(SQL_SUCCESS == SQLGetDiagRec((short)type, handle, 1, state, NULL, message, 1024, NULL))) {
51 - char *str_step = netdata_MSSQL_error_text(step);
52 - char *str_type = netdata_MSSQL_type_text(type);
53 - char *use_instance = (!instance) ? "no instance" : instance;
54 - nd_log(
55 - NDLS_COLLECTORS,
56 - NDLP_INFO,
57 - "MSSQL server error on %s using the handle %s running %s : %s, %s",
58 - use_instance,
59 - str_type,
60 - str_step,
61 - message,
62 - state);
63 - }
64 -}
65 -
66 -static inline void netdata_MSSQL_release_results(SQLHSTMT stmt)
67 -{
68 - if (stmt == SQL_NULL_HSTMT)
69 - return;
70 -
71 - SQLCloseCursor(stmt);
72 - SQLFreeStmt(stmt, SQL_UNBIND);
73 - SQLFreeStmt(stmt, SQL_RESET_PARAMS);
74 -}
75 -
76 -static ULONGLONG netdata_MSSQL_fill_long_value(SQLHSTMT stmt, const char *mask, const char *dbname, char *instance)
77 -{
78 - long db_size = 0;
79 - SQLLEN col_data_len = 0;
80 -
81 - SQLCHAR query[512];
82 - snprintfz((char *)query, 511, mask, dbname);
83 -
84 - SQLRETURN ret;
85 -
86 - ret = SQLExecDirect(stmt, query, SQL_NTS);
87 - if (likely(netdata_mssql_check_result(ret))) {
88 - netdata_MSSQL_error(SQL_HANDLE_STMT, stmt, NETDATA_MSSQL_ODBC_QUERY, instance);
89 - netdata_MSSQL_release_results(stmt);
90 - return (ULONGLONG)ULONG_LONG_MAX;
91 - }
92 -
93 - ret = SQLBindCol(stmt, 1, SQL_C_LONG, &db_size, sizeof(long), &col_data_len);
94 - if (likely(netdata_mssql_check_result(ret))) {
95 - netdata_MSSQL_error(SQL_HANDLE_STMT, stmt, NETDATA_MSSQL_ODBC_PREPARE, instance);
96 - netdata_MSSQL_release_results(stmt);
97 - return (ULONGLONG)ULONG_LONG_MAX;
98 - }
99 -
100 - ret = SQLFetch(stmt);
101 - if (likely(netdata_mssql_check_result(ret))) {
102 - netdata_MSSQL_error(SQL_HANDLE_STMT, stmt, NETDATA_MSSQL_ODBC_FETCH, instance);
103 - netdata_MSSQL_release_results(stmt);
104 - return (ULONGLONG)ULONG_LONG_MAX;
105 - }
106 -
107 - if (col_data_len == SQL_NULL_DATA)
108 - db_size = 0;
109 -
110 - netdata_MSSQL_release_results(stmt);
111 - return (ULONGLONG)(db_size * MEGA_FACTOR);
112 -}
113 -
114 -#define NETDATA_MSSQL_BUFFER_PAGE_READS_METRIC "Page reads/sec"
115 -#define NETDATA_MSSQL_BUFFER_PAGE_WRITES_METRIC "Page writes/sec"
116 -#define NETDATA_MSSQL_BUFFER_PAGE_CACHE_METRIC "Buffer cache hit ratio"
117 -#define NETDATA_MSSQL_BUFFER_CHECKPOINT_METRIC "Checkpoint pages/sec"
118 -#define NETDATA_MSSQL_BUFFER_PAGE_LIFE_METRIC "Page life expectancy"
119 -#define NETDATA_MSSQL_BUFFER_LAZY_WRITES_METRIC "Lazy writes/sec"
120 -#define NETDATA_MSSQL_BUFFER_PAGE_LOOKUPS_METRIC "Page Lookups/sec"
121 -
122 -#define NETDATA_MSSQL_STATS_COMPILATIONS_METRIC "SQL Compilations/sec"
123 -#define NETDATA_MSSQL_STATS_RECOMPILATIONS_METRIC "SQL Re-Compilations/sec"
124 -
125 -#define NETDATA_MSSQL_ACTIVE_TRANSACTIONS_METRIC "Active Transactions"
126 -#define NETDATA_MSSQL_TRANSACTION_PER_SEC_METRIC "Transactions/sec"
127 -#define NETDATA_MSSQL_WRITE_TRANSACTIONS_METRIC "Write Transactions/sec"
128 -#define NETDATA_MSSQL_BACKUP_RESTORE_METRIC "Backup/Restore Throughput/sec"
129 -#define NETDATA_MSSQL_LOG_FLUSHED_METRIC "Log Bytes Flushed/sec"
130 -#define NETDATA_MSSQL_LOG_FLUSHES_METRIC "Log Flushes/sec"
131 -#define NETDATA_MSSQL_NUMBER_DEADLOCKS_METRIC "Number of Deadlocks/sec"
132 -#define NETDATA_MSSQL_LOCK_WAITS_METRIC "Lock Waits/sec"
133 -#define NETDATA_MSSQL_LOCK_TIMEOUTS_METRIC "Lock Timeouts/sec"
134 -#define NETDATA_MSSQL_LOCK_REQUESTS_METRIC "Lock Requests/sec"
135 -
136 -bool netdata_mssql_counter_buffer(struct mssql_db_instance *mdi, char *inst_obj, long value)
137 -{
138 - bool ret = false;
139 - if (!strncmp(
140 - inst_obj, NETDATA_MSSQL_STATS_COMPILATIONS_METRIC, sizeof(NETDATA_MSSQL_STATS_COMPILATIONS_METRIC) - 1)) {
141 - mdi->MSSQLCompilations.current.Data = (ULONGLONG)value;
142 - ret = true;
143 - } else if (!strncmp(
144 - inst_obj,
145 - NETDATA_MSSQL_STATS_RECOMPILATIONS_METRIC,
146 - sizeof(NETDATA_MSSQL_STATS_RECOMPILATIONS_METRIC) - 1)) {
147 - mdi->MSSQLRecompilations.current.Data = (ULONGLONG)value;
148 - ret = true;
149 - } else if (!strncmp(
150 - inst_obj,
151 - NETDATA_MSSQL_BUFFER_PAGE_READS_METRIC,
152 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_READS_METRIC) - 1)) {
153 - mdi->MSSQLBufferPageReads.current.Data = (ULONGLONG)value;
154 - ret = true;
155 - } else if (!strncmp(
156 - inst_obj,
157 - NETDATA_MSSQL_BUFFER_PAGE_WRITES_METRIC,
158 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_WRITES_METRIC) - 1)) {
159 - mdi->MSSQLBufferPageWrites.current.Data = (ULONGLONG)value;
160 - ret = true;
161 - } else if (!strncmp(
162 - inst_obj,
163 - NETDATA_MSSQL_BUFFER_PAGE_CACHE_METRIC,
164 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_CACHE_METRIC) - 1)) {
165 - mdi->MSSQLBufferCacheHits.current.Data = (ULONGLONG)value;
166 - ret = true;
167 - } else if (!strncmp(
168 - inst_obj,
169 - NETDATA_MSSQL_BUFFER_CHECKPOINT_METRIC,
170 - sizeof(NETDATA_MSSQL_BUFFER_CHECKPOINT_METRIC) - 1)) {
171 - mdi->MSSQLBufferCheckpointPages.current.Data = (ULONGLONG)value;
172 - ret = true;
173 - } else if (!strncmp(
174 - inst_obj, NETDATA_MSSQL_BUFFER_PAGE_LIFE_METRIC, sizeof(NETDATA_MSSQL_BUFFER_PAGE_LIFE_METRIC) - 1)) {
175 - mdi->MSSQLBufferPageLifeExpectancy.current.Data = (ULONGLONG)value;
176 - ret = true;
177 - } else if (!strncmp(
178 - inst_obj,
179 - NETDATA_MSSQL_BUFFER_LAZY_WRITES_METRIC,
180 - sizeof(NETDATA_MSSQL_BUFFER_LAZY_WRITES_METRIC) - 1)) {
181 - mdi->MSSQLBufferLazyWrite.current.Data = (ULONGLONG)value;
182 - ret = true;
183 - } else if (!strncmp(
184 - inst_obj,
185 - NETDATA_MSSQL_BUFFER_PAGE_LOOKUPS_METRIC,
186 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_LOOKUPS_METRIC) - 1)) {
187 - mdi->MSSQLBufferPageLookups.current.Data = (ULONGLONG)value;
188 - ret = true;
189 - }
190 -
191 - return ret;
192 -}
193 -
194 -bool netdata_mssql_counter_transaction(struct mssql_db_instance *mdi, char *object_name, long value)
195 -{
196 - bool ret = false;
197 - if (unlikely(!strncmp(
198 - object_name,
199 - NETDATA_MSSQL_ACTIVE_TRANSACTIONS_METRIC,
200 - sizeof(NETDATA_MSSQL_ACTIVE_TRANSACTIONS_METRIC) - 1))) {
201 - mdi->MSSQLDatabaseActiveTransactions.current.Data = (ULONGLONG)value;
202 - ret = true;
203 - } else if (unlikely(!strncmp(
204 - object_name,
205 - NETDATA_MSSQL_TRANSACTION_PER_SEC_METRIC,
206 - sizeof(NETDATA_MSSQL_TRANSACTION_PER_SEC_METRIC) - 1))) {
207 - mdi->MSSQLDatabaseTransactions.current.Data = (ULONGLONG)value;
208 - ret = true;
209 - } else if (unlikely(!strncmp(
210 - object_name,
211 - NETDATA_MSSQL_WRITE_TRANSACTIONS_METRIC,
212 - sizeof(NETDATA_MSSQL_WRITE_TRANSACTIONS_METRIC) - 1))) {
213 - mdi->MSSQLDatabaseWriteTransactions.current.Data = (ULONGLONG)value;
214 - ret = true;
215 - }
216 -
217 - return ret;
218 -}
219 -
220 -bool netdata_mssql_counter_lock_and_log(struct mssql_db_instance *mdi, char *object_name, long value)
221 -{
222 - bool ret = false;
223 - if (unlikely(!strncmp(
224 - object_name, NETDATA_MSSQL_BACKUP_RESTORE_METRIC, sizeof(NETDATA_MSSQL_BACKUP_RESTORE_METRIC) - 1))) {
225 - mdi->MSSQLDatabaseBackupRestoreOperations.current.Data = (ULONGLONG)value;
226 - ret = true;
227 - } else if (unlikely(!strncmp(
228 - object_name, NETDATA_MSSQL_LOG_FLUSHED_METRIC, sizeof(NETDATA_MSSQL_LOG_FLUSHED_METRIC) - 1))) {
229 - mdi->MSSQLDatabaseLogFlushed.current.Data = (ULONGLONG)value;
230 - ret = true;
231 - } else if (unlikely(!strncmp(
232 - object_name, NETDATA_MSSQL_LOG_FLUSHES_METRIC, sizeof(NETDATA_MSSQL_LOG_FLUSHES_METRIC) - 1))) {
233 - mdi->MSSQLDatabaseLogFlushes.current.Data = (ULONGLONG)value;
234 - ret = true;
235 - } else if (unlikely(!strncmp(
236 - object_name,
237 - NETDATA_MSSQL_NUMBER_DEADLOCKS_METRIC,
238 - sizeof(NETDATA_MSSQL_NUMBER_DEADLOCKS_METRIC) - 1))) {
239 - mdi->MSSQLDatabaseDeadLockSec.current.Data = (ULONGLONG)value;
240 - ret = true;
241 - } else if (unlikely(!strncmp(
242 - object_name, NETDATA_MSSQL_LOCK_WAITS_METRIC, sizeof(NETDATA_MSSQL_LOCK_WAITS_METRIC) - 1))) {
243 - mdi->MSSQLDatabaseLockWaitSec.current.Data = (ULONGLONG)value;
244 - ret = true;
245 - } else if (unlikely(!strncmp(
246 - object_name, NETDATA_MSSQL_LOCK_TIMEOUTS_METRIC, sizeof(NETDATA_MSSQL_LOCK_TIMEOUTS_METRIC) - 1))) {
247 - mdi->MSSQLDatabaseLockTimeoutsSec.current.Data = (ULONGLONG)value;
248 - ret = true;
249 - } else if (unlikely(!strncmp(
250 - object_name, NETDATA_MSSQL_LOCK_REQUESTS_METRIC, sizeof(NETDATA_MSSQL_LOCK_REQUESTS_METRIC) - 1))) {
251 - mdi->MSSQLDatabaseLockRequestsSec.current.Data = (ULONGLONG)value;
252 - ret = true;
253 - }
254 -
255 - return ret;
256 -}
257 -
258 -void dict_mssql_fill_performance_counters(struct mssql_db_instance *mdi, const char *dbname)
259 -{
260 - char object_name[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};
261 - long value = 0;
262 - SQLLEN col_object_len = 0, col_value_len = 0;
263 -
264 - if (unlikely(
265 - !mdi->parent->conn->collect_transactions && !mdi->parent->conn->collect_buffer && !mdi->collect_instance))
266 - return;
267 -
268 - SQLCHAR query[sizeof(NETDATA_QUERY_PERFORMANCE_COUNTER) + 2 * NETDATA_MAX_INSTANCE_OBJECT + 1];
269 - // We are using the database name instead of the instance name because, on Windows, the instance name having the metrics
270 - // is often the same as the database name.
271 - snprintfz(
272 - (char *)query,
273 - sizeof(NETDATA_QUERY_PERFORMANCE_COUNTER) + 2 * NETDATA_MAX_INSTANCE_OBJECT,
274 - NETDATA_QUERY_PERFORMANCE_COUNTER,
275 - dbname,
276 - dbname);
277 -
278 - SQLRETURN ret = SQLExecDirect(mdi->parent->conn->dbPerfCounterSTMT, (SQLCHAR *)query, SQL_NTS);
279 - if (likely(netdata_mssql_check_result(ret))) {
280 - mdi->collecting_data = false;
281 - netdata_MSSQL_error(
282 - SQL_HANDLE_STMT, mdi->parent->conn->dbPerfCounterSTMT, NETDATA_MSSQL_ODBC_QUERY, mdi->parent->instanceID);
283 - goto endcounters;
284 - }
285 -
286 - ret = SQLBindCol(
287 - mdi->parent->conn->dbPerfCounterSTMT, 1, SQL_C_CHAR, object_name, sizeof(object_name), &col_object_len);
288 - if (likely(netdata_mssql_check_result(ret))) {
289 - netdata_MSSQL_error(
290 - SQL_HANDLE_STMT, mdi->parent->conn->dbPerfCounterSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);
291 - goto endcounters;
292 - }
293 -
294 - ret = SQLBindCol(mdi->parent->conn->dbPerfCounterSTMT, 2, SQL_C_LONG, &value, sizeof(value), &col_value_len);
295 - if (likely(netdata_mssql_check_result(ret))) {
296 - netdata_MSSQL_error(
297 - SQL_HANDLE_STMT, mdi->parent->conn->dbPerfCounterSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);
298 - goto endcounters;
299 - }
300 -
301 - do {
302 - ret = SQLFetch(mdi->parent->conn->dbPerfCounterSTMT);
303 - switch (ret) {
304 - case SQL_SUCCESS:
305 - case SQL_SUCCESS_WITH_INFO:
306 - break;
307 - case SQL_NO_DATA:
308 - default:
309 - goto endcounters;
310 - }
311 -
312 - if (col_object_len == SQL_NULL_DATA)
313 - continue;
314 - if (col_value_len == SQL_NULL_DATA)
315 - value = 0;
316 -
317 - if (netdata_mssql_counter_buffer(mdi, object_name, value))
318 - continue;
319 -
320 - if (netdata_mssql_counter_transaction(mdi, object_name, value))
321 - continue;
322 -
323 - if (netdata_mssql_counter_lock_and_log(mdi, object_name, value))
324 - continue;
325 -
326 - } while (true);
327 -
328 -endcounters:
329 - netdata_MSSQL_release_results(mdi->parent->conn->dbPerfCounterSTMT);
330 -}
331 -
332 -void dict_mssql_fill_locks(struct mssql_db_instance *mdi, const char *dbname)
333 -{
334 -#define NETDATA_MSSQL_MAX_RESOURCE_TYPE (60)
335 - char resource_type[NETDATA_MSSQL_MAX_RESOURCE_TYPE + 1] = {};
336 - long value = 0;
337 - SQLLEN col_object_len = 0, col_value_len = 0;
338 -
339 - SQLCHAR query[sizeof(NETDATA_QUERY_LOCKS_MASK) + 2 * NETDATA_MAX_INSTANCE_OBJECT + 1];
340 - snprintfz(
341 - (char *)query,
342 - sizeof(NETDATA_QUERY_LOCKS_MASK) + 2 * NETDATA_MAX_INSTANCE_OBJECT,
343 - NETDATA_QUERY_LOCKS_MASK,
344 - dbname,
345 - dbname);
346 -
347 - SQLRETURN ret = SQLExecDirect(mdi->parent->conn->dbLocksSTMT, (SQLCHAR *)query, SQL_NTS);
348 - if (likely(netdata_mssql_check_result(ret))) {
349 - mdi->collecting_data = false;
350 - netdata_MSSQL_error(
351 - SQL_HANDLE_STMT, mdi->parent->conn->dbLocksSTMT, NETDATA_MSSQL_ODBC_QUERY, mdi->parent->instanceID);
352 - goto endlocks;
353 - }
354 -
355 - ret = SQLBindCol(
356 - mdi->parent->conn->dbLocksSTMT, 1, SQL_C_CHAR, resource_type, sizeof(resource_type), &col_object_len);
357 - if (likely(netdata_mssql_check_result(ret))) {
358 - netdata_MSSQL_error(
359 - SQL_HANDLE_STMT, mdi->parent->conn->dbLocksSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);
360 - goto endlocks;
361 - }
362 -
363 - ret = SQLBindCol(mdi->parent->conn->dbLocksSTMT, 2, SQL_C_LONG, &value, sizeof(value), &col_value_len);
364 - if (likely(netdata_mssql_check_result(ret))) {
365 - netdata_MSSQL_error(
366 - SQL_HANDLE_STMT, mdi->parent->conn->dbLocksSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);
367 - goto endlocks;
368 - }
369 -
370 - do {
371 - ret = SQLFetch(mdi->parent->conn->dbLocksSTMT);
372 - switch (ret) {
373 - case SQL_SUCCESS:
374 - case SQL_SUCCESS_WITH_INFO:
375 - break;
376 - case SQL_NO_DATA:
377 - default:
378 - goto endlocks;
379 - }
380 -
381 - if (col_object_len == SQL_NULL_DATA)
382 - continue;
383 - if (col_value_len == SQL_NULL_DATA)
384 - value = 0;
385 -
386 - char *space = strchr(resource_type, ' ');
387 - if (likely(space))
388 - *space = '\0';
389 -
390 - struct mssql_lock_instance *mli =
391 - dictionary_set(mdi->parent->locks_instances, resource_type, NULL, sizeof(*mli));
392 - if (unlikely(!mli))
393 - continue;
394 -
395 - mli->lockWait.current.Data = value;
396 - } while (true);
397 -
398 -endlocks:
399 - netdata_MSSQL_release_results(mdi->parent->conn->dbLocksSTMT);
400 -}
401 -
402 -int dict_mssql_fill_waits(struct mssql_instance *mi)
403 -{
404 - if (unlikely(!mi->conn->collect_waits))
405 - return 1;
406 -
407 - char wait_type[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};
408 - char wait_category[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};
409 - SQLBIGINT total_wait = 0;
410 - SQLBIGINT resource_wait = 0;
411 - SQLBIGINT signal_wait = 0;
412 - SQLBIGINT max_wait = 0;
413 - SQLBIGINT waiting_tasks = 0;
414 - int success = 0;
415 - SQLLEN col_wait_type_len = 0, col_total_wait_len = 0, col_resource_wait_len = 0, col_signal_wait_len = 0,
416 - col_max_wait_len = 0, col_waiting_tasks_len = 0, col_wait_category_len = 0;
417 -
418 - SQLRETURN ret = SQLExecDirect(mi->conn->dbWaitsSTMT, (SQLCHAR *)NETDATA_QUERY_CHECK_WAITS, SQL_NTS);
419 - if (likely(netdata_mssql_check_result(ret))) {
420 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
421 - goto endwait;
422 - }
423 -
424 - ret = SQLBindCol(mi->conn->dbWaitsSTMT, 1, SQL_C_CHAR, wait_type, sizeof(wait_type), &col_wait_type_len);
425 - if (likely(netdata_mssql_check_result(ret))) {
426 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
427 - goto endwait;
428 - }
429 -
430 - ret = SQLBindCol(mi->conn->dbWaitsSTMT, 2, SQL_C_SBIGINT, &total_wait, sizeof(total_wait), &col_total_wait_len);
431 - if (likely(netdata_mssql_check_result(ret))) {
432 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
433 - goto endwait;
434 - }
435 -
436 - ret = SQLBindCol(
437 - mi->conn->dbWaitsSTMT, 3, SQL_C_SBIGINT, &resource_wait, sizeof(resource_wait), &col_resource_wait_len);
438 - if (likely(netdata_mssql_check_result(ret))) {
439 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
440 - goto endwait;
441 - }
442 -
443 - ret = SQLBindCol(mi->conn->dbWaitsSTMT, 4, SQL_C_SBIGINT, &signal_wait, sizeof(signal_wait), &col_signal_wait_len);
444 - if (likely(netdata_mssql_check_result(ret))) {
445 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
446 - goto endwait;
447 - }
448 -
449 - ret = SQLBindCol(mi->conn->dbWaitsSTMT, 5, SQL_C_SBIGINT, &max_wait, sizeof(max_wait), &col_max_wait_len);
450 - if (likely(netdata_mssql_check_result(ret))) {
451 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
452 - goto endwait;
453 - }
454 -
455 - ret = SQLBindCol(
456 - mi->conn->dbWaitsSTMT, 6, SQL_C_SBIGINT, &waiting_tasks, sizeof(waiting_tasks), &col_waiting_tasks_len);
457 - if (likely(netdata_mssql_check_result(ret))) {
458 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
459 - goto endwait;
460 - }
461 -
462 - ret =
463 - SQLBindCol(mi->conn->dbWaitsSTMT, 7, SQL_C_CHAR, wait_category, sizeof(wait_category), &col_wait_category_len);
464 - if (likely(netdata_mssql_check_result(ret))) {
465 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbWaitsSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
466 - goto endwait;
467 - }
468 -
469 - do {
470 - ret = SQLFetch(mi->conn->dbWaitsSTMT);
471 - switch (ret) {
472 - case SQL_SUCCESS:
473 - case SQL_SUCCESS_WITH_INFO:
474 - break;
475 - case SQL_NO_DATA:
476 - default:
477 - success = 1;
478 - goto endwait;
479 - }
480 -
481 - if (col_wait_type_len == SQL_NULL_DATA)
482 - continue;
483 - if (col_total_wait_len == SQL_NULL_DATA)
484 - total_wait = 0;
485 - if (col_resource_wait_len == SQL_NULL_DATA)
486 - resource_wait = 0;
487 - if (col_signal_wait_len == SQL_NULL_DATA)
488 - signal_wait = 0;
489 - if (col_max_wait_len == SQL_NULL_DATA)
490 - max_wait = 0;
491 - if (col_waiting_tasks_len == SQL_NULL_DATA)
492 - waiting_tasks = 0;
493 - if (col_wait_category_len == SQL_NULL_DATA)
494 - wait_category[0] = '\0';
495 -
496 - struct mssql_db_waits *mdw = dictionary_set(mi->waits, wait_type, NULL, sizeof(*mdw));
497 - if (!mdw)
498 - continue;
499 -
500 - mdw->MSSQLDatabaseTotalWait.current.Data = (ULONGLONG)total_wait;
501 - if (unlikely(resource_wait < 0))
502 - resource_wait = 0;
503 - mdw->MSSQLDatabaseResourceWaitMSec.current.Data = (ULONGLONG)resource_wait;
504 - mdw->MSSQLDatabaseSignalWaitMSec.current.Data = (ULONGLONG)signal_wait;
505 - mdw->MSSQLDatabaseMaxWaitTimeMSec.current.Data = (ULONGLONG)max_wait;
506 - mdw->MSSQLDatabaseWaitingTasks.current.Data = (ULONGLONG)waiting_tasks;
507 -
508 - if (unlikely(!mdw->wait_category))
509 - mdw->wait_category = strdupz(wait_category);
510 - } while (true);
511 -
512 -endwait:
513 - netdata_MSSQL_release_results(mi->conn->dbWaitsSTMT);
514 -
515 - return success;
516 -}
517 -
518 -int netdata_select_db(SQLHDBC hdbc, const char *database)
519 -{
520 - SQLHSTMT hstmt;
521 - SQLRETURN ret;
522 -
523 - ret = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
524 - if (likely(netdata_mssql_check_result(ret))) {
525 - return -1;
526 - }
527 -
528 - char query[512];
529 - snprintfz(query, sizeof(query), "USE %s", database);
530 - ret = SQLExecDirect(hstmt, (SQLCHAR *)query, SQL_NTS);
531 - int result = 0;
532 - if (likely(netdata_mssql_check_result(ret))) {
533 - result = -1;
534 - }
535 - SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
536 - return result;
537 -}
538 -
539 -void dict_mssql_fill_replication(struct mssql_db_instance *mdi)
540 -{
541 - char publisher[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};
542 - char publisher_db[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};
543 - char publication[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};
544 - char key[NETDATA_MAX_INSTANCE_OBJECT * 2 + 2];
545 - int type = 0, status = 0, warning = 0, avg_latency = 0, retention = 0, subscriptioncount = 0,
546 - runningdistagentcount = 0, average_runspeedPerf = 0;
547 - SQLLEN publisher_len = 0, publisherdb_len = 0, publication_len = 0, type_len = 0, status_len = 0, warning_len = 0,
548 - avg_latency_len = 0, retention_len = 0, subscriptioncount_len = 0, runningagentcount_len = 0,
549 - average_runspeedperf_len = 0;
550 -
551 - if (likely(netdata_select_db(mdi->parent->conn->netdataSQLHDBc, NETDATA_REPLICATION_DB))) {
552 - return;
553 - }
554 -
555 - SQLRETURN ret =
556 - SQLExecDirect(mdi->parent->conn->dbReplicationPublisher, (SQLCHAR *)NETDATA_REPLICATION_MONITOR_QUERY, SQL_NTS);
557 - if (likely(netdata_mssql_check_result(ret))) {
558 - mdi->collecting_data = false;
559 - netdata_MSSQL_error(
560 - SQL_HANDLE_STMT,
561 - mdi->parent->conn->dbReplicationPublisher,
562 - NETDATA_MSSQL_ODBC_QUERY,
563 - mdi->parent->instanceID);
564 - goto endreplication;
565 - }
566 -
567 - ret = SQLBindCol(
568 - mdi->parent->conn->dbReplicationPublisher, 1, SQL_C_CHAR, publisher_db, sizeof(publisher_db), &publisherdb_len);
569 - if (likely(netdata_mssql_check_result(ret))) {
570 - netdata_MSSQL_error(
571 - SQL_HANDLE_STMT,
572 - mdi->parent->conn->dbReplicationPublisher,
573 - NETDATA_MSSQL_ODBC_PREPARE,
574 - mdi->parent->instanceID);
575 - goto endreplication;
576 - }
577 -
578 - ret = SQLBindCol(
579 - mdi->parent->conn->dbReplicationPublisher, 2, SQL_C_CHAR, publication, sizeof(publication), &publication_len);
580 - if (likely(netdata_mssql_check_result(ret))) {
581 - netdata_MSSQL_error(
582 - SQL_HANDLE_STMT,
583 - mdi->parent->conn->dbReplicationPublisher,
584 - NETDATA_MSSQL_ODBC_PREPARE,
585 - mdi->parent->instanceID);
586 - goto endreplication;
587 - }
588 -
589 - ret = SQLBindCol(mdi->parent->conn->dbReplicationPublisher, 4, SQL_C_LONG, &type, sizeof(type), &type_len);
590 - if (likely(netdata_mssql_check_result(ret))) {
591 - netdata_MSSQL_error(
592 - SQL_HANDLE_STMT,
593 - mdi->parent->conn->dbReplicationPublisher,
594 - NETDATA_MSSQL_ODBC_PREPARE,
595 - mdi->parent->instanceID);
596 - goto endreplication;
597 - }
598 -
599 - ret = SQLBindCol(mdi->parent->conn->dbReplicationPublisher, 5, SQL_C_LONG, &status, sizeof(status), &status_len);
600 - if (likely(netdata_mssql_check_result(ret))) {
601 - netdata_MSSQL_error(
602 - SQL_HANDLE_STMT,
603 - mdi->parent->conn->dbReplicationPublisher,
604 - NETDATA_MSSQL_ODBC_PREPARE,
605 - mdi->parent->instanceID);
606 - goto endreplication;
607 - }
608 -
609 - ret = SQLBindCol(mdi->parent->conn->dbReplicationPublisher, 6, SQL_C_LONG, &warning, sizeof(warning), &warning_len);
610 - if (likely(netdata_mssql_check_result(ret))) {
611 - netdata_MSSQL_error(
612 - SQL_HANDLE_STMT,
613 - mdi->parent->conn->dbReplicationPublisher,
614 - NETDATA_MSSQL_ODBC_PREPARE,
615 - mdi->parent->instanceID);
616 - goto endreplication;
617 - }
618 -
619 - ret = SQLBindCol(
620 - mdi->parent->conn->dbReplicationPublisher, 9, SQL_C_LONG, &avg_latency, sizeof(avg_latency), &avg_latency_len);
621 - if (likely(netdata_mssql_check_result(ret))) {
622 - // It is still a NULL value
623 - avg_latency = 0;
624 - }
625 -
626 - ret = SQLBindCol(
627 - mdi->parent->conn->dbReplicationPublisher, 11, SQL_C_LONG, &retention, sizeof(retention), &retention_len);
628 - if (likely(netdata_mssql_check_result(ret))) {
629 - netdata_MSSQL_error(
630 - SQL_HANDLE_STMT,
631 - mdi->parent->conn->dbReplicationPublisher,
632 - NETDATA_MSSQL_ODBC_PREPARE,
633 - mdi->parent->instanceID);
634 - goto endreplication;
635 - }
636 -
637 - ret = SQLBindCol(
638 - mdi->parent->conn->dbReplicationPublisher,
639 - 15,
640 - SQL_C_LONG,
641 - &subscriptioncount,
642 - sizeof(subscriptioncount),
643 - &subscriptioncount_len);
644 - if (likely(netdata_mssql_check_result(ret))) {
645 - netdata_MSSQL_error(
646 - SQL_HANDLE_STMT,
647 - mdi->parent->conn->dbReplicationPublisher,
648 - NETDATA_MSSQL_ODBC_PREPARE,
649 - mdi->parent->instanceID);
650 - goto endreplication;
651 - }
652 -
653 - ret = SQLBindCol(
654 - mdi->parent->conn->dbReplicationPublisher,
655 - 16,
656 - SQL_C_LONG,
657 - &runningdistagentcount,
658 - sizeof(runningdistagentcount),
659 - &runningagentcount_len);
660 - if (likely(netdata_mssql_check_result(ret))) {
661 - netdata_MSSQL_error(
662 - SQL_HANDLE_STMT,
663 - mdi->parent->conn->dbReplicationPublisher,
664 - NETDATA_MSSQL_ODBC_PREPARE,
665 - mdi->parent->instanceID);
666 - goto endreplication;
667 - }
668 -
669 - ret = SQLBindCol(
670 - mdi->parent->conn->dbReplicationPublisher,
671 - 22,
672 - SQL_C_LONG,
673 - &average_runspeedPerf,
674 - sizeof(average_runspeedPerf),
675 - &average_runspeedperf_len);
676 - if (likely(netdata_mssql_check_result(ret))) {
677 - netdata_MSSQL_error(
678 - SQL_HANDLE_STMT,
679 - mdi->parent->conn->dbReplicationPublisher,
680 - NETDATA_MSSQL_ODBC_PREPARE,
681 - mdi->parent->instanceID);
682 - goto endreplication;
683 - }
684 -
685 - ret = SQLBindCol(
686 - mdi->parent->conn->dbReplicationPublisher, 24, SQL_C_CHAR, publisher, sizeof(publisher), &publisher_len);
687 - if (likely(netdata_mssql_check_result(ret))) {
688 - netdata_MSSQL_error(
689 - SQL_HANDLE_STMT,
690 - mdi->parent->conn->dbReplicationPublisher,
691 - NETDATA_MSSQL_ODBC_PREPARE,
692 - mdi->parent->instanceID);
693 - goto endreplication;
694 - }
695 -
696 - do {
697 - ret = SQLFetch(mdi->parent->conn->dbReplicationPublisher);
698 - switch (ret) {
699 - case SQL_SUCCESS:
700 - case SQL_SUCCESS_WITH_INFO:
701 - break;
702 - case SQL_NO_DATA:
703 - default:
704 - goto endreplication;
705 - }
706 -
707 - if (publisherdb_len == SQL_NULL_DATA)
708 - publisher_db[0] = '\0';
709 - if (publication_len == SQL_NULL_DATA)
710 - publication[0] = '\0';
711 - if (type_len == SQL_NULL_DATA)
712 - type = 0;
713 - if (status_len == SQL_NULL_DATA)
714 - status = 0;
715 - if (warning_len == SQL_NULL_DATA)
716 - warning = 0;
717 - if (avg_latency_len == SQL_NULL_DATA)
718 - avg_latency = 0;
719 - if (retention_len == SQL_NULL_DATA)
720 - retention = 0;
721 - if (subscriptioncount_len == SQL_NULL_DATA)
722 - subscriptioncount = 0;
723 - if (runningagentcount_len == SQL_NULL_DATA)
724 - runningdistagentcount = 0;
725 - if (average_runspeedperf_len == SQL_NULL_DATA)
726 - average_runspeedPerf = 0;
727 - if (publisher_len == SQL_NULL_DATA)
728 - publisher[0] = '\0';
729 -
730 - if (unlikely(!publisher_db[0] || !publication[0]))
731 - continue;
732 -
733 - snprintfz(key, sizeof(key) - 1, "%s:%s", publisher_db, publication);
734 - struct mssql_publisher_publication *mpp =
735 - dictionary_set(mdi->parent->publisher_publication, key, NULL, sizeof(*mpp));
736 -
737 - if (unlikely(!mpp->publisher)) {
738 - mpp->publisher = strdupz(publisher);
739 - mpp->parent = mdi->parent;
740 - }
741 -
742 - if (unlikely(!mpp->publication))
743 - mpp->publication = strdupz(publication);
744 -
745 - if (unlikely(!mpp->db))
746 - mpp->db = strdupz(publisher_db);
747 -
748 - mpp->type = type;
749 - mpp->status = status;
750 - mpp->warning = warning;
751 -
752 - mpp->avg_latency = avg_latency;
753 -
754 - mpp->retention = retention;
755 -
756 - mpp->subscriptioncount = subscriptioncount;
757 - mpp->runningdistagentcount = runningdistagentcount;
758 -
759 - mpp->average_runspeedPerf = average_runspeedPerf;
760 - } while (true);
761 -
762 -endreplication:
763 - (void)netdata_select_db(mdi->parent->conn->netdataSQLHDBc, "master");
764 - netdata_MSSQL_release_results(mdi->parent->conn->dbReplicationPublisher);
765 -}
766 -
767 -int dict_mssql_databases_run_queries(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
768 -{
769 - struct mssql_db_instance *mdi = value;
770 - const char *dbname = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
771 -
772 - if (unlikely(!mdi->collecting_data || !mdi->parent || !mdi->parent->conn)) {
773 - goto enddrunquery;
774 - }
775 -
776 - // We failed to collect this for the database, so we are not going to try again
777 - if (unlikely(mdi->MSSQLDatabaseDataFileSize.current.Data != ULONG_LONG_MAX)) {
778 - if (likely(mdi->parent->conn->collect_data_size))
779 - mdi->MSSQLDatabaseDataFileSize.current.Data = netdata_MSSQL_fill_long_value(
780 - mdi->parent->conn->dataFileSizeSTMT, NETDATA_QUERY_DATA_FILE_SIZE_MASK, dbname, mdi->parent->instanceID);
781 - } else {
782 - mdi->collecting_data = false;
783 - goto enddrunquery;
784 - }
785 -
786 - dict_mssql_fill_performance_counters(mdi, dbname);
787 - dict_mssql_fill_locks(mdi, dbname);
788 -
789 - if (likely(mdi->running_replication && mdi->parent->conn->collect_replication))
790 - dict_mssql_fill_replication(mdi);
791 -
792 -enddrunquery:
793 - return 1;
794 -}
795 -
796 -long netdata_mssql_check_permission(struct mssql_instance *mi)
797 -{
798 - static int next_try = NETDATA_MSSQL_NEXT_TRY - 1;
799 - long perm = 0;
800 - SQLLEN col_data_len = 0;
801 -
802 - if (++next_try != NETDATA_MSSQL_NEXT_TRY)
803 - return 1;
804 -
805 - next_try = 0;
806 -
807 - SQLRETURN ret;
808 -
809 - ret = SQLExecDirect(mi->conn->checkPermSTMT, (SQLCHAR *)NETDATA_QUERY_CHECK_PERM, SQL_NTS);
810 - if (likely(netdata_mssql_check_result(ret))) {
811 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->checkPermSTMT, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
812 - perm = LONG_MAX;
813 - goto endperm;
814 - }
815 -
816 - ret = SQLBindCol(mi->conn->checkPermSTMT, 1, SQL_C_LONG, &perm, sizeof(perm), &col_data_len);
817 -
818 - if (likely(netdata_mssql_check_result(ret))) {
819 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->checkPermSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
820 - perm = LONG_MAX;
821 - goto endperm;
822 - }
823 -
824 - ret = SQLFetch(mi->conn->checkPermSTMT);
825 - if (likely(netdata_mssql_check_result(ret))) {
826 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->checkPermSTMT, NETDATA_MSSQL_ODBC_FETCH, mi->instanceID);
827 - perm = LONG_MAX;
828 - goto endperm;
829 - }
830 -
831 - if (col_data_len == SQL_NULL_DATA)
832 - perm = 0;
833 -
834 -endperm:
835 - netdata_MSSQL_release_results(mi->conn->checkPermSTMT);
836 - return perm;
837 -}
838 -
839 -void netdata_mssql_fill_mssql_status(struct mssql_instance *mi)
840 -{
841 - char dbname[SQLSERVER_MAX_NAME_LENGTH + 1];
842 - int readonly = 0;
843 - BYTE state = 0;
844 - SQLLEN col_data_len = 0, col_state_len = 0, col_readonly_len = 0;
845 - static int next_try = NETDATA_MSSQL_NEXT_TRY - 1;
846 -
847 - if (unlikely(++next_try != NETDATA_MSSQL_NEXT_TRY))
848 - return;
849 -
850 - next_try = 0;
851 -
852 - SQLRETURN ret;
853 -
854 - ret = SQLExecDirect(mi->conn->dbSQLState, (SQLCHAR *)NETDATA_QUERY_DATABASE_STATUS, SQL_NTS);
855 - if (likely(netdata_mssql_check_result(ret))) {
856 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLState, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
857 - goto enddbstate;
858 - }
859 -
860 - ret = SQLBindCol(mi->conn->dbSQLState, 1, SQL_C_CHAR, dbname, sizeof(dbname), &col_data_len);
861 - if (likely(netdata_mssql_check_result(ret))) {
862 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLState, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
863 - goto enddbstate;
864 - }
865 -
866 - ret = SQLBindCol(mi->conn->dbSQLState, 2, SQL_C_TINYINT, &state, sizeof(state), &col_state_len);
867 - if (likely(netdata_mssql_check_result(ret))) {
868 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLState, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
869 - goto enddbstate;
870 - }
871 -
872 - ret = SQLBindCol(mi->conn->dbSQLState, 3, SQL_C_BIT, &readonly, sizeof(readonly), &col_readonly_len);
873 - if (likely(netdata_mssql_check_result(ret))) {
874 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLState, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
875 - goto enddbstate;
876 - }
877 -
878 - do {
879 - ret = SQLFetch(mi->conn->dbSQLState);
880 - if (likely(netdata_mssql_check_result(ret))) {
881 - goto enddbstate;
882 - }
883 -
884 - if (col_data_len == SQL_NULL_DATA)
885 - continue;
886 - if (col_state_len == SQL_NULL_DATA)
887 - state = 0;
888 - if (col_readonly_len == SQL_NULL_DATA)
889 - readonly = 0;
890 -
891 - struct mssql_db_instance *mdi = dictionary_set(mi->databases, dbname, NULL, sizeof(*mdi));
892 - if (unlikely(!mdi))
893 - continue;
894 -
895 - mdi->MSSQLDBState.current.Data = (ULONGLONG)state;
896 - mdi->MSSQLDBIsReadonly.current.Data = (ULONGLONG)readonly;
897 - } while (true);
898 -
899 -enddbstate:
900 - netdata_MSSQL_release_results(mi->conn->dbSQLState);
901 -}
902 -
903 -void netdata_mssql_fill_job_status(struct mssql_instance *mi)
904 -{
905 - char job[SQLSERVER_MAX_NAME_LENGTH + 1];
906 - BYTE state = 0;
907 - SQLLEN col_job_len = 0;
908 - SQLLEN col_state_len = 0;
909 -
910 - static int next_try = NETDATA_MSSQL_NEXT_TRY - 1;
911 -
912 - if (unlikely(++next_try != NETDATA_MSSQL_NEXT_TRY))
913 - return;
914 -
915 - next_try = 0;
916 -
917 - SQLRETURN ret;
918 -
919 - ret = SQLExecDirect(mi->conn->dbSQLJobs, (SQLCHAR *)NETDATA_QUERY_JOBS_STATUS, SQL_NTS);
920 - if (likely(netdata_mssql_check_result(ret))) {
921 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLJobs, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
922 - goto enddbjobs;
923 - }
924 -
925 - ret = SQLBindCol(mi->conn->dbSQLJobs, 1, SQL_C_CHAR, job, sizeof(job), &col_job_len);
926 - if (likely(netdata_mssql_check_result(ret))) {
927 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLJobs, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
928 - goto enddbjobs;
929 - }
930 -
931 - ret = SQLBindCol(mi->conn->dbSQLJobs, 2, SQL_C_TINYINT, &state, sizeof(state), &col_state_len);
932 - if (likely(netdata_mssql_check_result(ret))) {
933 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLJobs, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
934 - goto enddbjobs;
935 - }
936 -
937 - do {
938 - ret = SQLFetch(mi->conn->dbSQLJobs);
939 - if (likely(netdata_mssql_check_result(ret))) {
940 - goto enddbjobs;
941 - }
942 -
943 - if (col_job_len == SQL_NULL_DATA)
944 - continue;
945 - if (col_state_len == SQL_NULL_DATA)
946 - state = 0;
947 -
948 - struct mssql_db_jobs *mdj = dictionary_set(mi->sysjobs, job, NULL, sizeof(*mdj));
949 - if (unlikely(!mdj))
950 - continue;
951 -
952 - mdj->MSSQLJOBState.current.Data = (ULONGLONG)state;
953 - } while (true);
954 -
955 -enddbjobs:
956 - netdata_MSSQL_release_results(mi->conn->dbSQLJobs);
957 -}
958 -
959 -void netdata_mssql_fill_user_connection(struct mssql_instance *mi)
960 -{
961 - if (unlikely(!mi->conn->collect_user_connections))
962 - return;
963 -
964 - mi->MSSQLUserConnections.current.Data = 0;
965 - mi->MSSQLSessionConnections.current.Data = 0;
966 -
967 - collected_number connections = 0;
968 - unsigned char is_user;
969 - SQLLEN col_user_connections_len = 0;
970 - SQLLEN col_user_bit_len = 0;
971 -
972 - SQLRETURN ret;
973 -
974 - ret = SQLExecDirect(mi->conn->dbSQLConnections, (SQLCHAR *)NETDATA_QUERY_CONNECTIONS, SQL_NTS);
975 - if (likely(netdata_mssql_check_result(ret))) {
976 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLConnections, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
977 - goto enduserconn;
978 - }
979 -
980 - ret = SQLBindCol(
981 - mi->conn->dbSQLConnections, 1, SQL_C_LONG, &connections, sizeof(connections), &col_user_connections_len);
982 - if (likely(netdata_mssql_check_result(ret))) {
983 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLConnections, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
984 - goto enduserconn;
985 - }
986 -
987 - ret = SQLBindCol(mi->conn->dbSQLConnections, 2, SQL_C_BIT, &is_user, sizeof(is_user), &col_user_bit_len);
988 - if (likely(netdata_mssql_check_result(ret))) {
989 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLConnections, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
990 - goto enduserconn;
991 - }
992 -
993 - do {
994 - ret = SQLFetch(mi->conn->dbSQLConnections);
995 - if (likely(netdata_mssql_check_result(ret))) {
996 - goto enduserconn;
997 - }
998 -
999 - if (col_user_connections_len == SQL_NULL_DATA)
1000 - connections = 0;
1001 - if (col_user_bit_len == SQL_NULL_DATA)
1002 - is_user = 0;
1003 -
1004 - if (is_user)
1005 - mi->MSSQLUserConnections.current.Data = (ULONGLONG)connections;
1006 - else
1007 - mi->MSSQLSessionConnections.current.Data = (ULONGLONG)connections;
1008 - } while (true);
1009 -
1010 -enduserconn:
1011 - netdata_MSSQL_release_results(mi->conn->dbSQLConnections);
1012 -}
1013 -
1014 -static void netdata_mssql_fill_blocked_processes_query(struct mssql_instance *mi)
1015 -{
1016 - if (unlikely(!mi || !mi->conn || mi->conn->dbSQLBlockedProcesses == SQL_NULL_HSTMT))
1017 - return;
1018 -
1019 - long blocked_processes = 0;
1020 - SQLLEN col_len = 0;
1021 - mi->MSSQLBlockedProcesses.current.Data = 0;
1022 -
1023 - SQLRETURN ret = SQLExecDirect(mi->conn->dbSQLBlockedProcesses, (SQLCHAR *)NETDATA_QUERY_BLOCKED_PROCESSES, SQL_NTS);
1024 - if (likely(netdata_mssql_check_result(ret))) {
1025 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLBlockedProcesses, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
1026 - goto end_blocked_processes;
1027 - }
1028 -
1029 - ret = SQLBindCol(
1030 - mi->conn->dbSQLBlockedProcesses, 1, SQL_C_LONG, &blocked_processes, sizeof(blocked_processes), &col_len);
1031 - if (likely(netdata_mssql_check_result(ret))) {
1032 - netdata_MSSQL_error(
1033 - SQL_HANDLE_STMT, mi->conn->dbSQLBlockedProcesses, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
1034 - goto end_blocked_processes;
1035 - }
1036 -
1037 - ret = SQLFetch(mi->conn->dbSQLBlockedProcesses);
1038 - if (likely(netdata_mssql_check_result(ret)))
1039 - goto end_blocked_processes;
1040 -
1041 - mi->MSSQLBlockedProcesses.current.Data = blocked_processes;
1042 -end_blocked_processes:
1043 - netdata_MSSQL_release_results(mi->conn->dbSQLBlockedProcesses);
1044 -}
1045 -
1046 -void netdata_mssql_fill_dictionary_from_db(struct mssql_instance *mi)
1047 -{
1048 - char dbname[SQLSERVER_MAX_NAME_LENGTH + 1];
1049 - SQLLEN col_data_len = 0;
1050 -
1051 - static int next_try = NETDATA_MSSQL_NEXT_TRY - 1;
1052 -
1053 - if (unlikely(++next_try != NETDATA_MSSQL_NEXT_TRY))
1054 - return;
1055 -
1056 - next_try = 0;
1057 -
1058 - SQLRETURN ret;
1059 -
1060 - ret = SQLExecDirect(mi->conn->databaseListSTMT, (SQLCHAR *)NETDATA_QUERY_LIST_DB, SQL_NTS);
1061 - if (likely(netdata_mssql_check_result(ret))) {
1062 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->databaseListSTMT, NETDATA_MSSQL_ODBC_QUERY, mi->instanceID);
1063 - goto enddblist;
1064 - }
1065 -
1066 - ret = SQLBindCol(mi->conn->databaseListSTMT, 1, SQL_C_CHAR, dbname, sizeof(dbname), &col_data_len);
1067 -
1068 - if (likely(netdata_mssql_check_result(ret))) {
1069 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->databaseListSTMT, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);
1070 - goto enddblist;
1071 - }
1072 -
1073 - int i = 0;
1074 - do {
1075 - ret = SQLFetch(mi->conn->databaseListSTMT);
1076 - if (likely(netdata_mssql_check_result(ret))) {
1077 - goto enddblist;
1078 - }
1079 -
1080 - if (col_data_len == SQL_NULL_DATA)
1081 - continue;
1082 -
1083 - struct mssql_db_instance *mdi = dictionary_set(mi->databases, dbname, NULL, sizeof(*mdi));
1084 - if (!mdi)
1085 - continue;
1086 -
1087 - mdi->updated = 0;
1088 - if (unlikely(!mdi->parent)) {
1089 - mdi->parent = mi;
1090 - }
1091 -
1092 - if (mi->conn && !strncmp(dbname, NETDATA_REPLICATION_DB, sizeof(NETDATA_REPLICATION_DB) - 1)) {
1093 - mdi->running_replication = true;
1094 - }
1095 -
1096 - if (unlikely(!i)) {
1097 - mdi->collect_instance = true;
1098 - }
1099 - i++;
1100 - } while (true);
1101 -
1102 -enddblist:
1103 - netdata_MSSQL_release_results(mi->conn->databaseListSTMT);
1104 -}
1105 -
1106 -static bool netdata_MSSQL_initialize_connection(struct netdata_mssql_conn *nmc)
1107 -{
1108 - SQLRETURN ret;
1109 - if (unlikely(!nmc->netdataSQLEnv)) {
1110 - ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &nmc->netdataSQLEnv);
1111 - if (likely(netdata_mssql_check_result(ret)))
1112 - return FALSE;
1113 -
1114 - ret = SQLSetEnvAttr(nmc->netdataSQLEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0);
1115 - if (likely(netdata_mssql_check_result(ret))) {
1116 - return FALSE;
1117 - }
1118 - }
1119 -
1120 - ret = SQLAllocHandle(SQL_HANDLE_DBC, nmc->netdataSQLEnv, &nmc->netdataSQLHDBc);
1121 - if (likely(netdata_mssql_check_result(ret))) {
1122 - return FALSE;
1123 - }
1124 -
1125 - ret = SQLSetConnectAttr(nmc->netdataSQLHDBc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0);
1126 - if (likely(netdata_mssql_check_result(ret))) {
1127 - return FALSE;
1128 - }
1129 -
1130 - ret = SQLSetConnectAttr(nmc->netdataSQLHDBc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)TRUE, 0);
1131 - if (likely(netdata_mssql_check_result(ret))) {
1132 - return FALSE;
1133 - }
1134 -
1135 - SQLCHAR ret_conn_str[1024];
1136 - ret = SQLDriverConnect(
1137 - nmc->netdataSQLHDBc, NULL, nmc->connectionString, SQL_NTS, ret_conn_str, 1024, NULL, SQL_DRIVER_NOPROMPT);
1138 -
1139 - BOOL retConn;
1140 - switch (ret) {
1141 - case SQL_NO_DATA_FOUND:
1142 - case SQL_INVALID_HANDLE:
1143 - case SQL_ERROR:
1144 - default:
1145 - netdata_MSSQL_error(SQL_HANDLE_DBC, nmc->netdataSQLHDBc, NETDATA_MSSQL_ODBC_CONNECT, NULL);
1146 - retConn = FALSE;
1147 - break;
1148 - case SQL_SUCCESS:
1149 - case SQL_SUCCESS_WITH_INFO:
1150 - retConn = TRUE;
1151 - break;
1152 - }
1153 -
1154 - if (likely(retConn)) {
1155 - SQLSetConnectAttr(nmc->netdataSQLHDBc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, 0);
1156 -
1157 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->checkPermSTMT);
1158 - if (likely(netdata_mssql_check_result(ret))) {
1159 - retConn = FALSE;
1160 - goto endMSSQLInitializationConnection;
1161 - }
1162 -
1163 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->databaseListSTMT);
1164 - if (likely(netdata_mssql_check_result(ret))) {
1165 - retConn = FALSE;
1166 - goto endMSSQLInitializationConnection;
1167 - }
1168 -
1169 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dataFileSizeSTMT);
1170 - if (likely(netdata_mssql_check_result(ret))) {
1171 - retConn = FALSE;
1172 - goto endMSSQLInitializationConnection;
1173 - }
1174 -
1175 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbPerfCounterSTMT);
1176 - if (likely(netdata_mssql_check_result(ret))) {
1177 - retConn = FALSE;
1178 - goto endMSSQLInitializationConnection;
1179 - }
1180 -
1181 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbInstanceTransactionSTMT);
1182 - if (likely(netdata_mssql_check_result(ret))) {
1183 - retConn = FALSE;
1184 - goto endMSSQLInitializationConnection;
1185 - }
1186 -
1187 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbLocksSTMT);
1188 - if (likely(netdata_mssql_check_result(ret))) {
1189 - retConn = FALSE;
1190 - goto endMSSQLInitializationConnection;
1191 - }
1192 -
1193 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbWaitsSTMT);
1194 - if (likely(netdata_mssql_check_result(ret))) {
1195 - retConn = FALSE;
1196 - goto endMSSQLInitializationConnection;
1197 - }
1198 -
1199 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbSQLState);
1200 - if (likely(netdata_mssql_check_result(ret))) {
1201 - retConn = FALSE;
1202 - goto endMSSQLInitializationConnection;
1203 - }
1204 -
1205 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbSQLJobs);
1206 - if (likely(netdata_mssql_check_result(ret))) {
1207 - retConn = FALSE;
1208 - goto endMSSQLInitializationConnection;
1209 - }
1210 -
1211 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbSQLConnections);
1212 - if (likely(netdata_mssql_check_result(ret))) {
1213 - retConn = FALSE;
1214 - goto endMSSQLInitializationConnection;
1215 - }
1216 -
1217 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbSQLBlockedProcesses);
1218 - if (likely(netdata_mssql_check_result(ret))) {
1219 - retConn = FALSE;
1220 - goto endMSSQLInitializationConnection;
1221 - }
1222 -
1223 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbReplicationPublisher);
1224 - if (likely(netdata_mssql_check_result(ret))) {
1225 - retConn = FALSE;
1226 - goto endMSSQLInitializationConnection;
1227 - }
1228 - }
1229 -
1230 -endMSSQLInitializationConnection:
1231 - return retConn;
1232 -}
1233 -
1234 -// Dictionary
1235 -static DICTIONARY *mssql_instances = NULL;
1236 -
1237 -static void initialize_mssql_objects(struct mssql_instance *mi, const char *instance)
1238 -{
1239 - char prefix[NETDATA_MAX_INSTANCE_NAME];
1240 - if (unlikely(!strcmp(instance, "MSSQLSERVER"))) {
1241 - strncpyz(prefix, "SQLServer:", sizeof(prefix) - 1);
1242 - } else if (unlikely(!strcmp(instance, "SQLEXPRESS"))) {
1243 - strncpyz(prefix, "MSSQL$SQLEXPRESS:", sizeof(prefix) - 1);
1244 - if (mi->conn)
1245 - mi->conn->is_sqlexpress = true;
1246 - } else {
1247 - char *express = (mi->conn && mi->conn->is_sqlexpress) ? "SQLEXPRESS:" : "";
1248 - snprintfz(prefix, sizeof(prefix) - 1, "MSSQL$%s%s:", express, instance);
1249 - }
1250 -
1251 - size_t length = strlen(prefix);
1252 - char name[NETDATA_MAX_INSTANCE_OBJECT];
1253 - snprintfz(name, sizeof(name) - 1, "%s%s", prefix, "General Statistics");
1254 - mi->objectName[NETDATA_MSSQL_GENERAL_STATS] = strdupz(name);
1255 -
1256 - strncpyz(&name[length], "SQL Errors", sizeof(name) - length);
1257 - mi->objectName[NETDATA_MSSQL_SQL_ERRORS] = strdupz(name);
1258 -
1259 - strncpyz(&name[length], "Databases", sizeof(name) - length);
1260 - mi->objectName[NETDATA_MSSQL_DATABASE] = strdupz(name);
1261 -
1262 - strncpyz(&name[length], "SQL Statistics", sizeof(name) - length);
1263 - mi->objectName[NETDATA_MSSQL_SQL_STATS] = strdupz(name);
1264 -
1265 - strncpyz(&name[length], "Buffer Manager", sizeof(name) - length);
1266 - mi->objectName[NETDATA_MSSQL_BUFFER_MANAGEMENT] = strdupz(name);
1267 -
1268 - strncpyz(&name[length], "SystemJobs", sizeof(name) - length);
1269 - mi->objectName[NETDATA_MSSQL_JOBS] = strdupz(name);
1270 -
1271 - mi->objectName[NETDATA_USER_CONNECTIONS] = NULL;
1272 -
1273 - strncpyz(&name[length], "Memory Manager", sizeof(name) - length);
1274 - mi->objectName[NETDATA_MSSQL_MEMORY] = strdupz(name);
1275 -
1276 - strncpyz(&name[length], "Locks", sizeof(name) - length);
1277 - mi->objectName[NETDATA_MSSQL_LOCKS] = strdupz(name);
1278 -
1279 - strncpyz(&name[length], "Wait Statistics", sizeof(name) - length);
1280 - mi->objectName[NETDATA_MSSQL_WAITS] = strdupz(name);
1281 -
1282 - strncpyz(&name[length], "Access Methods", sizeof(name) - length);
1283 - mi->objectName[NETDATA_MSSQL_ACCESS_METHODS] = strdupz(name);
1284 -
1285 - mi->instanceID = strdupz(instance);
1286 -}
1287 -
1288 -static inline void initialize_mssql_keys(struct mssql_instance *mi)
1289 -{
1290 - // General Statistics (https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-general-statistics-object)
1291 - mi->MSSQLUserConnections.key = "User Connections";
1292 - mi->MSSQLBlockedProcesses.key = "Processes blocked";
1293 -
1294 - // SQL Statistics (https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-statistics-object)
1295 - mi->MSSQLStatsAutoParameterization.key = "Auto-Param Attempts/sec";
1296 - mi->MSSQLStatsBatchRequests.key = "Batch Requests/sec";
1297 - mi->MSSQLStatSafeAutoParameterization.key = "Safe Auto-Params/sec";
1298 -
1299 - // Access Methods (https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-access-methods-object)
1300 - mi->MSSQLAccessMethodPageSplits.key = "Page Splits/sec";
1301 -
1302 - // Errors (https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-errors-object)
1303 - mi->MSSQLSQLErrorsTotal.key = "Errors/sec";
1304 -
1305 - // Memory Management (https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-memory-manager-object)
1306 - mi->MSSQLConnectionMemoryBytes.key = "Connection Memory (KB)";
1307 - mi->MSSQLExternalBenefitOfMemory.key = "External benefit of memory";
1308 - mi->MSSQLPendingMemoryGrants.key = "Memory Grants Pending";
1309 - mi->MSSQLTotalServerMemory.key = "Total Server Memory (KB)";
1310 -}
1311 -
1312 -void dict_mssql_insert_locks_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1313 -{
1314 - const char *resource = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
1315 -
1316 - // https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-locks-object
1317 - struct mssql_lock_instance *ptr = value;
1318 - ptr->resourceID = strdupz(resource);
1319 - ptr->deadLocks.key = "Number of Deadlocks/sec";
1320 - ptr->lockWait.key = "Lock Waits/sec";
1321 -}
1322 -
1323 -void dict_mssql_insert_wait_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1324 -{
1325 - const char *type = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
1326 -
1327 - struct mssql_db_waits *mdw = value;
1328 -
1329 - mdw->wait_type = strdupz(type);
1330 - mdw->wait_category = NULL;
1331 - mdw->rd_total_wait = mdw->rd_max_wait_time_msec = mdw->rd_resource_wait_msec = mdw->rd_signal_wait_msec =
1332 - mdw->rd_waiting_tasks = NULL;
1333 -}
1334 -
1335 -void dict_mssql_insert_databases_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1336 -{
1337 - struct mssql_db_instance *mdi = value;
1338 -
1339 - mdi->collecting_data = true;
1340 -}
1341 -
1342 -void dict_mssql_insert_replication_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1343 -{
1344 - UNUSED(value);
1345 -}
1346 -
1347 -void dict_mssql_insert_jobs_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1348 -{
1349 - UNUSED(value);
1350 -}
1351 -
1352 -// Options
1353 -void netdata_mount_mssql_connection_string(struct netdata_mssql_conn *dbInput)
1354 -{
1355 - SQLCHAR conn[2048];
1356 - const char *serverAddress;
1357 - const char *serverAddressArg;
1358 - if (unlikely(!dbInput)) {
1359 - return;
1360 - }
1361 -
1362 - if (likely(dbInput->server && dbInput->address)) {
1363 - nd_log(
1364 - NDLS_COLLECTORS,
1365 - NDLP_ERR,
1366 - "Collector is not expecting server and address defined together, please, select one of them.");
1367 - dbInput->connectionString = NULL;
1368 - return;
1369 - }
1370 -
1371 - if (likely(dbInput->server)) {
1372 - serverAddress = "Server";
1373 - serverAddressArg = dbInput->server;
1374 - } else {
1375 - serverAddressArg = "Address";
1376 - serverAddress = dbInput->address;
1377 - }
1378 -
1379 - char auth[1024];
1380 - if (likely(dbInput->windows_auth))
1381 - snprintfz(auth, sizeof(auth) - 1, "Trusted_Connection = yes");
1382 - else if (unlikely(!dbInput->username || !dbInput->password)) {
1383 - nd_log(
1384 - NDLS_COLLECTORS,
1385 - NDLP_ERR,
1386 - "You are not using Windows Authentication. Thus, it is necessary to specify user and password.");
1387 - dbInput->connectionString = NULL;
1388 - return;
1389 - } else {
1390 - snprintfz(auth, sizeof(auth) - 1, "UID=%s;PWD=%s;", dbInput->username, dbInput->password);
1391 - }
1392 -
1393 - if (likely(dbInput->trust_server_certificate)) {
1394 - size_t length = strlen(auth);
1395 - snprintfz(&auth[length], sizeof(auth) - length, ";TrustServerCertificate=True;");
1396 - }
1397 -
1398 - snprintfz(
1399 - (char *)conn, sizeof(conn) - 1, "Driver={%s};%s=%s;%s", dbInput->driver, serverAddress, serverAddressArg, auth);
1400 - dbInput->connectionString = (SQLCHAR *)strdupz((char *)conn);
1401 -}
1402 -
1403 -static void netdata_read_config_options()
1404 -{
1405 -#define NETDATA_MAX_MSSSQL_SECTION_LENGTH (40)
1406 -#define NETDATA_DEFAULT_MSSQL_SECTION "plugin:windows:PerflibMSSQL"
1407 - uint16_t expected_instances = 1;
1408 - uint16_t total_instances = 0;
1409 - for (; total_instances < expected_instances; total_instances++) {
1410 - char section_name[NETDATA_MAX_MSSSQL_SECTION_LENGTH + 1];
1411 - char upper_instance[NETDATA_MAX_INSTANCE_OBJECT + 1];
1412 - strncpyz(section_name, NETDATA_DEFAULT_MSSQL_SECTION, sizeof(NETDATA_DEFAULT_MSSQL_SECTION));
1413 - if (likely(total_instances)) {
1414 - snprintfz(&section_name[sizeof(NETDATA_DEFAULT_MSSQL_SECTION) - 1], 5, "%d", total_instances);
1415 - }
1416 - const char *instance = inicfg_get(&netdata_config, section_name, "instance", NULL);
1417 - int additional_instances = (int)inicfg_get_number(&netdata_config, section_name, "additional instances", 0);
1418 - if (!instance || strlen(instance) > NETDATA_MAX_INSTANCE_OBJECT) {
1419 - nd_log(
1420 - NDLS_COLLECTORS,
1421 - NDLP_ERR,
1422 - "You must specify a valid 'instance' name to collect data from database in section %s.",
1423 - section_name);
1424 - continue;
1425 - }
1426 -
1427 - if (!total_instances && additional_instances) {
1428 - if (additional_instances > 64) {
1429 - nd_log(NDLS_COLLECTORS, NDLP_ERR, "Number of instances is bigger than expected (64)");
1430 - expected_instances = 64;
1431 - }
1432 - expected_instances = additional_instances + 1;
1433 - }
1434 -
1435 - const char *move = instance;
1436 - int i;
1437 - for (i = 0; *move; move++, i++) {
1438 - upper_instance[i] = toupper(*move);
1439 - }
1440 - upper_instance[i] = '\0';
1441 -
1442 - struct netdata_mssql_conn *dbconn = dictionary_set(conn_options, upper_instance, NULL, sizeof(*dbconn));
1443 -
1444 - dbconn->instance = strdupz(upper_instance);
1445 - dbconn->driver = inicfg_get(&netdata_config, section_name, "driver", "SQL Server");
1446 - dbconn->server = inicfg_get(&netdata_config, section_name, "server", NULL);
1447 - dbconn->address = inicfg_get(&netdata_config, section_name, "address", NULL);
1448 - dbconn->username = inicfg_get(&netdata_config, section_name, "uid", NULL);
1449 - dbconn->password = inicfg_get(&netdata_config, section_name, "pwd", NULL);
1450 - dbconn->instances = additional_instances;
1451 - dbconn->windows_auth = inicfg_get_boolean(&netdata_config, section_name, "windows authentication", false);
1452 - dbconn->is_sqlexpress = inicfg_get_boolean(&netdata_config, section_name, "express", false);
1453 - dbconn->collect_transactions = inicfg_get_boolean(&netdata_config, section_name, "collect transactions", true);
1454 - dbconn->collect_waits = inicfg_get_boolean(&netdata_config, section_name, "collect waits", true);
1455 - dbconn->collect_locks = inicfg_get_boolean(&netdata_config, section_name, "collect lock metrics", true);
1456 - dbconn->collect_replication = inicfg_get_boolean(&netdata_config, section_name, "collect replication", true);
1457 - dbconn->collect_jobs = inicfg_get_boolean(&netdata_config, section_name, "collect jobs", true);
1458 - dbconn->collect_buffer = inicfg_get_boolean(&netdata_config, section_name, "collect buffer stats", true);
1459 - dbconn->collect_data_size = inicfg_get_boolean(&netdata_config, section_name, "collect database size", true);
1460 - dbconn->collect_user_connections =
1461 - inicfg_get_boolean(&netdata_config, section_name, "collect user connections", true);
1462 - dbconn->collect_blocked_processes =
1463 - inicfg_get_boolean(&netdata_config, section_name, "collect blocked processes", true);
1464 - dbconn->is_connected = FALSE;
1465 - dbconn->trust_server_certificate = inicfg_get_boolean(&netdata_config, section_name, "trust server certificate",
1466 - true);
1467 -
1468 - netdata_mount_mssql_connection_string(dbconn);
1469 - }
1470 -}
1471 -
1472 -static inline struct netdata_mssql_conn *netdata_mssql_get_conn_option(const char *instance)
1473 -{
1474 - return (struct netdata_mssql_conn *)dictionary_get(conn_options, instance);
1475 -}
1476 -
1477 -void mssql_fill_initial_instances(struct mssql_instance *mi)
1478 -{
1479 - // https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-locks-object?view=sql-server-ver17
1480 - char *keys[] = {
1481 - "AllocUnit",
1482 - "Application",
1483 - "Database",
1484 - "Extent",
1485 - "File",
1486 - "HoBT",
1487 - "Key",
1488 - "Metadata",
1489 - "OIB",
1490 - "Object",
1491 - "Page",
1492 - "RID",
1493 - "RowGroup",
1494 - "Xact",
1495 - NULL};
1496 - for (int i = 0; keys[i]; i++) {
1497 - (void)dictionary_set(mi->locks_instances, keys[i], NULL, sizeof(struct mssql_lock_instance));
1498 - }
1499 -}
1500 -
1501 -void dict_mssql_insert_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1502 -{
1503 - struct mssql_instance *mi = value;
1504 - const char *instance = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
1505 - bool *create_thread = data;
1506 -
1507 - if (unlikely(!mi->locks_instances)) {
1508 - mi->locks_instances = dictionary_create_advanced(
1509 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct mssql_lock_instance));
1510 - dictionary_register_insert_callback(mi->locks_instances, dict_mssql_insert_locks_cb, NULL);
1511 - mssql_fill_initial_instances(mi);
1512 - }
1513 -
1514 - if (unlikely(!mi->databases)) {
1515 - mi->databases = dictionary_create_advanced(
1516 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct mssql_db_instance));
1517 - dictionary_register_insert_callback(mi->databases, dict_mssql_insert_databases_cb, NULL);
1518 - }
1519 -
1520 - if (unlikely(!mi->publisher_publication)) {
1521 - mi->publisher_publication = dictionary_create_advanced(
1522 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
1523 - NULL,
1524 - sizeof(struct mssql_publisher_publication));
1525 - dictionary_register_insert_callback(mi->publisher_publication, dict_mssql_insert_replication_cb, NULL);
1526 - }
1527 -
1528 - if (unlikely(!mi->sysjobs)) {
1529 - mi->sysjobs = dictionary_create_advanced(
1530 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct mssql_db_jobs));
1531 - dictionary_register_insert_callback(mi->sysjobs, dict_mssql_insert_jobs_cb, NULL);
1532 - }
1533 -
1534 - if (unlikely(!mi->waits)) {
1535 - mi->waits = dictionary_create_advanced(
1536 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct mssql_db_waits));
1537 - dictionary_register_insert_callback(mi->waits, dict_mssql_insert_wait_cb, NULL);
1538 - }
1539 -
1540 - initialize_mssql_objects(mi, instance);
1541 - initialize_mssql_keys(mi);
1542 - mi->conn = netdata_mssql_get_conn_option(instance);
1543 -
1544 - if (likely(mi->conn && mi->conn->connectionString)) {
1545 - mi->conn->is_connected = netdata_MSSQL_initialize_connection(mi->conn);
1546 - if (mi->conn->is_connected)
1547 - *create_thread = true;
1548 - }
1549 -}
1550 -
1551 -void dict_mssql_insert_conn_option(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1552 -{
1553 - ;
1554 -}
1555 -
1556 -static void mssql_fill_dictionary(int update_every)
1557 -{
1558 - HKEY hKey;
1559 - LSTATUS ret = RegOpenKeyExA(
1560 - HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Microsoft SQL Server\\Instance Names\\SQL", 0, KEY_READ, &hKey);
1561 - if (ret != ERROR_SUCCESS)
1562 - return;
1563 -
1564 - DWORD values = 0;
1565 -
1566 - ret = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &values, NULL, NULL, NULL, NULL);
1567 - if (likely(ret != ERROR_SUCCESS)) {
1568 - goto endMSSQLFillDict;
1569 - }
1570 -
1571 - if (unlikely(!values)) {
1572 - ret = ERROR_PATH_NOT_FOUND;
1573 - goto endMSSQLFillDict;
1574 - }
1575 -
1576 -// https://learn.microsoft.com/en-us/windows/win32/sysinfo/enumerating-registry-subkeys
1577 -#define REGISTRY_MAX_VALUE 16383
1578 -
1579 - DWORD i;
1580 - char avalue[REGISTRY_MAX_VALUE] = {'\0'};
1581 - for (i = 0; i < values; i++) {
1582 - avalue[0] = '\0';
1583 - DWORD length = REGISTRY_MAX_VALUE;
1584 -
1585 - ret = RegEnumValue(hKey, i, avalue, &length, NULL, NULL, NULL, NULL);
1586 - if (likely(ret != ERROR_SUCCESS))
1587 - continue;
1588 -
1589 - struct mssql_instance *p = dictionary_set(mssql_instances, avalue, NULL, sizeof(*p));
1590 - p->update_every = update_every;
1591 - }
1592 -
1593 -endMSSQLFillDict:
1594 - RegCloseKey(hKey);
1595 -}
1596 -
1597 -int netdata_mssql_reset_value(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1598 -{
1599 - struct mssql_db_instance *mdi = value;
1600 -
1601 - mdi->collecting_data = false;
1602 -
1603 - return 1;
1604 -}
1605 -
1606 -int dict_mssql_query_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1607 -{
1608 - struct mssql_instance *mi = value;
1609 - static long collecting = 1;
1610 -
1611 - if (likely(mi->conn && mi->conn->is_connected && collecting)) {
1612 - collecting = netdata_mssql_check_permission(mi);
1613 - if (!collecting) {
1614 - nd_log(
1615 - NDLS_COLLECTORS,
1616 - NDLP_ERR,
1617 - "User %s does not have permission to run queries on %s",
1618 - mi->conn->username,
1619 - mi->instanceID);
1620 - } else {
1621 - netdata_mssql_fill_dictionary_from_db(mi);
1622 - netdata_mssql_fill_mssql_status(mi);
1623 - netdata_mssql_fill_job_status(mi);
1624 - netdata_mssql_fill_user_connection(mi);
1625 - if (likely(mi->conn->collect_blocked_processes))
1626 - netdata_mssql_fill_blocked_processes_query(mi);
1627 - dictionary_sorted_walkthrough_read(mi->databases, dict_mssql_databases_run_queries, NULL);
1628 - }
1629 -
1630 - collecting = dict_mssql_fill_waits(mi);
1631 - } else {
1632 - dictionary_sorted_walkthrough_read(mi->databases, netdata_mssql_reset_value, NULL);
1633 - }
1634 -
1635 - return 1;
1636 -}
1637 -
1638 -static void netdata_mssql_queries(void *ptr __maybe_unused)
1639 -{
1640 - heartbeat_t hb;
1641 - heartbeat_init(&hb, USEC_PER_SEC);
1642 - int update_every = UPDATE_EVERY_MIN;
1643 -
1644 - while (service_running(SERVICE_COLLECTORS)) {
1645 - (void)heartbeat_next(&hb);
1646 -
1647 - if (unlikely(!service_running(SERVICE_COLLECTORS)))
1648 - break;
1649 -
1650 - dictionary_sorted_walkthrough_read(mssql_instances, dict_mssql_query_cb, &update_every);
1651 - }
1652 -}
1653 -
1654 -static ND_THREAD *mssql_queries_thread = NULL;
1655 -
1656 -static int initialize(int update_every)
1657 -{
1658 - static bool create_thread = false;
1659 - mssql_instances = dictionary_create_advanced(
1660 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct mssql_instance));
1661 -
1662 - dictionary_register_insert_callback(mssql_instances, dict_mssql_insert_cb, &create_thread);
1663 -
1664 - conn_options = dictionary_create_advanced(
1665 - DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct netdata_mssql_conn));
1666 - dictionary_register_insert_callback(conn_options, dict_mssql_insert_conn_option, NULL);
1667 -
1668 - netdata_read_config_options();
1669 - mssql_fill_dictionary(update_every);
1670 -
1671 - if (likely(create_thread)) {
1672 - mssql_queries_thread =
1673 - nd_thread_create("mssql_queries", NETDATA_THREAD_OPTION_DEFAULT, netdata_mssql_queries, &update_every);
1674 - }
1675 -
1676 - return 0;
1677 -}
1678 -
1679 -// Charts
1680 -void netdata_mssql_blocked_processes_chart(struct mssql_instance *mi, int update_every)
1681 -{
1682 - if (unlikely(!mi->st_process_blocked)) {
1683 - char id[RRD_ID_LENGTH_MAX + 1];
1684 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_blocked_process", mi->instanceID);
1685 - netdata_fix_chart_name(id);
1686 - mi->st_process_blocked = rrdset_create_localhost(
1687 - "mssql",
1688 - id,
1689 - NULL,
1690 - "processes",
1691 - "mssql.instance_blocked_processes",
1692 - "Blocked processes",
1693 - "process",
1694 - PLUGIN_WINDOWS_NAME,
1695 - "PerflibMSSQL",
1696 - PRIO_MSSQL_BLOCKED_PROCESSES,
1697 - update_every,
1698 - RRDSET_TYPE_LINE);
1699 -
1700 - mi->rd_process_blocked = rrddim_add(mi->st_process_blocked, "blocked", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1701 -
1702 - rrdlabels_add(mi->st_process_blocked->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1703 - }
1704 -
1705 - rrddim_set_by_pointer(
1706 - mi->st_process_blocked, mi->rd_process_blocked, (collected_number)mi->MSSQLBlockedProcesses.current.Data);
1707 - rrdset_done(mi->st_process_blocked);
1708 -}
1709 -
1710 -static void
1711 -do_mssql_blocked_processes(PERF_DATA_BLOCK *pDataBlock __maybe_unused, struct mssql_instance *mi, int update_every)
1712 -{
1713 - if (unlikely(!mi || !mi->conn || !mi->conn->collect_blocked_processes))
1714 - return;
1715 -
1716 - netdata_mssql_blocked_processes_chart(mi, update_every);
1717 -}
1718 -
1719 -void dict_mssql_locks_wait_charts(struct mssql_instance *mi, struct mssql_lock_instance *mli, const char *resource)
1720 -{
1721 - if (unlikely(!mli->st_lockWait)) {
1722 - char id[RRD_ID_LENGTH_MAX + 1];
1723 -
1724 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_resource_%s_lock_wait", mi->instanceID, resource);
1725 - netdata_fix_chart_name(id);
1726 - mli->st_lockWait = rrdset_create_localhost(
1727 - "mssql",
1728 - id,
1729 - NULL,
1730 - "locks",
1731 - "mssql.instance_resource_lock_waits",
1732 - "Lock requests that required the caller to wait per resource",
1733 - "locks/s",
1734 - PLUGIN_WINDOWS_NAME,
1735 - "PerflibMSSQL",
1736 - PRIO_MSSQL_LOCKS_WAIT,
1737 - mi->update_every,
1738 - RRDSET_TYPE_LINE);
1739 -
1740 - rrdlabels_add(mli->st_lockWait->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1741 - rrdlabels_add(mli->st_lockWait->rrdlabels, "resource", resource, RRDLABEL_SRC_AUTO);
1742 - mli->rd_lockWait = rrddim_add(mli->st_lockWait, "locks", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1743 - }
1744 -
1745 - rrddim_set_by_pointer(mli->st_lockWait, mli->rd_lockWait, (collected_number)mli->lockWait.current.Data);
1746 - rrdset_done(mli->st_lockWait);
1747 -}
1748 -
1749 -void dict_mssql_dead_locks_charts(struct mssql_instance *mi, struct mssql_lock_instance *mli, const char *resource)
1750 -{
1751 - if (unlikely(!mli->st_deadLocks)) {
1752 - char id[RRD_ID_LENGTH_MAX + 1];
1753 -
1754 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_resource_%s_deadlocks", mi->instanceID, resource);
1755 - netdata_fix_chart_name(id);
1756 - mli->st_deadLocks = rrdset_create_localhost(
1757 - "mssql",
1758 - id,
1759 - NULL,
1760 - "locks",
1761 - "mssql.instance_resource_deadlocks",
1762 - "Active lock requests that resulted in deadlock per resource",
1763 - "deadlocks/s",
1764 - PLUGIN_WINDOWS_NAME,
1765 - "PerflibMSSQL",
1766 - PRIO_MSSQL_LOCKS_DEADLOCK_PER_RESOURCE,
1767 - mi->update_every,
1768 - RRDSET_TYPE_LINE);
1769 -
1770 - rrdlabels_add(mli->st_deadLocks->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1771 - rrdlabels_add(mli->st_deadLocks->rrdlabels, "resource", resource, RRDLABEL_SRC_AUTO);
1772 - mli->rd_deadLocks = rrddim_add(mli->st_deadLocks, "deadlocks", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1773 - }
1774 -
1775 - rrddim_set_by_pointer(mli->st_deadLocks, mli->rd_deadLocks, (collected_number)mli->deadLocks.current.Data);
1776 - rrdset_done(mli->st_deadLocks);
1777 -}
1778 -
1779 -int dict_mssql_locks_charts_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
1780 -{
1781 - const char *dimension = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
1782 - struct mssql_lock_instance *mli = value;
1783 - struct mssql_instance *mi = data;
1784 -
1785 - dict_mssql_locks_wait_charts(mi, mli, dimension);
1786 - dict_mssql_dead_locks_charts(mi, mli, dimension);
1787 -
1788 - return 1;
1789 -}
1790 -
1791 -static void do_mssql_locks(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every __maybe_unused)
1792 -{
1793 - if (unlikely(!pDataBlock))
1794 - goto end_mssql_locks;
1795 -
1796 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_LOCKS]);
1797 - if (likely(pObjectType)) {
1798 - if (likely(pObjectType->NumInstances)) {
1799 - PERF_INSTANCE_DEFINITION *pi = NULL;
1800 - for (LONG i = 0; i < pObjectType->NumInstances; i++) {
1801 - pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
1802 - if (unlikely(!pi))
1803 - break;
1804 -
1805 - if (unlikely(!getInstanceName(
1806 - pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer))))
1807 - strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
1808 -
1809 - if (unlikely(!strcasecmp(windows_shared_buffer, "_Total")))
1810 - continue;
1811 -
1812 - struct mssql_lock_instance *mli =
1813 - dictionary_set(mi->locks_instances, windows_shared_buffer, NULL, sizeof(*mli));
1814 - if (unlikely(!mli))
1815 - continue;
1816 -
1817 - perflibGetInstanceCounter(pDataBlock, pObjectType, pi, &mli->deadLocks);
1818 - perflibGetInstanceCounter(pDataBlock, pObjectType, pi, &mli->lockWait);
1819 - }
1820 - }
1821 - }
1822 -
1823 -end_mssql_locks:
1824 - dictionary_sorted_walkthrough_read(mi->locks_instances, dict_mssql_locks_charts_cb, mi);
1825 -}
1826 -
1827 -void mssql_total_wait_charts(struct mssql_instance *mi, struct mssql_db_waits *mdw, const char *type)
1828 -{
1829 - if (unlikely(!mdw->st_total_wait)) {
1830 - char id[RRD_ID_LENGTH_MAX + 1];
1831 -
1832 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_%s_total_wait", mi->instanceID, type);
1833 - netdata_fix_chart_name(id);
1834 - mdw->st_total_wait = rrdset_create_localhost(
1835 - "mssql",
1836 - id,
1837 - NULL,
1838 - "locks",
1839 - "mssql.instance_total_wait_time",
1840 - "Wait time for each wait type and category",
1841 - "ms",
1842 - PLUGIN_WINDOWS_NAME,
1843 - "PerflibMSSQL",
1844 - PRIO_MSSQL_WAITS_TOTAL,
1845 - mi->update_every,
1846 - RRDSET_TYPE_LINE);
1847 -
1848 - rrdlabels_add(mdw->st_total_wait->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1849 - rrdlabels_add(mdw->st_total_wait->rrdlabels, "wait_type", mdw->wait_type, RRDLABEL_SRC_AUTO);
1850 - rrdlabels_add(mdw->st_total_wait->rrdlabels, "wait_category", mdw->wait_category, RRDLABEL_SRC_AUTO);
1851 - mdw->rd_total_wait = rrddim_add(mdw->st_total_wait, "duration", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1852 - }
1853 -
1854 - rrddim_set_by_pointer(
1855 - mdw->st_total_wait, mdw->rd_total_wait, (collected_number)mdw->MSSQLDatabaseTotalWait.current.Data);
1856 -
1857 - rrdset_done(mdw->st_total_wait);
1858 -}
1859 -
1860 -void mssql_resource_wait_charts(struct mssql_instance *mi, struct mssql_db_waits *mdw, const char *type)
1861 -{
1862 - if (unlikely(!mdw->st_resource_wait_msec)) {
1863 - char id[RRD_ID_LENGTH_MAX + 1];
1864 -
1865 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_%s_resource_wait", mi->instanceID, type);
1866 - netdata_fix_chart_name(id);
1867 - mdw->st_resource_wait_msec = rrdset_create_localhost(
1868 - "mssql",
1869 - id,
1870 - NULL,
1871 - "locks",
1872 - "mssql.instance_resource_wait_time",
1873 - "Wait time for threads waiting on specific resource types for each wait type and category",
1874 - "ms",
1875 - PLUGIN_WINDOWS_NAME,
1876 - "PerflibMSSQL",
1877 - PRIO_MSSQL_RESOURCE_WAIT,
1878 - mi->update_every,
1879 - RRDSET_TYPE_LINE);
1880 -
1881 - rrdlabels_add(mdw->st_resource_wait_msec->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1882 - rrdlabels_add(mdw->st_resource_wait_msec->rrdlabels, "wait_type", mdw->wait_type, RRDLABEL_SRC_AUTO);
1883 - rrdlabels_add(mdw->st_resource_wait_msec->rrdlabels, "wait_category", mdw->wait_category, RRDLABEL_SRC_AUTO);
1884 - mdw->rd_resource_wait_msec =
1885 - rrddim_add(mdw->st_resource_wait_msec, "duration", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1886 - }
1887 -
1888 - rrddim_set_by_pointer(
1889 - mdw->st_resource_wait_msec,
1890 - mdw->rd_resource_wait_msec,
1891 - (collected_number)mdw->MSSQLDatabaseResourceWaitMSec.current.Data);
1892 -
1893 - rrdset_done(mdw->st_resource_wait_msec);
1894 -}
1895 -
1896 -void mssql_signal_wait_charts(struct mssql_instance *mi, struct mssql_db_waits *mdw, const char *type)
1897 -{
1898 - if (unlikely(!mdw->st_signal_wait_msec)) {
1899 - char id[RRD_ID_LENGTH_MAX + 1];
1900 -
1901 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_%s_signal_wait", mi->instanceID, type);
1902 - netdata_fix_chart_name(id);
1903 - mdw->st_signal_wait_msec = rrdset_create_localhost(
1904 - "mssql",
1905 - id,
1906 - NULL,
1907 - "locks",
1908 - "mssql.instance_signal_wait_time",
1909 - "Delay between thread wakeup signal and actual execution start for each wait type and category",
1910 - "ms",
1911 - PLUGIN_WINDOWS_NAME,
1912 - "PerflibMSSQL",
1913 - PRIO_MSSQL_SIGNAL_WAIT,
1914 - mi->update_every,
1915 - RRDSET_TYPE_LINE);
1916 -
1917 - rrdlabels_add(mdw->st_signal_wait_msec->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1918 - rrdlabels_add(mdw->st_signal_wait_msec->rrdlabels, "wait_type", mdw->wait_type, RRDLABEL_SRC_AUTO);
1919 - rrdlabels_add(mdw->st_signal_wait_msec->rrdlabels, "wait_category", mdw->wait_category, RRDLABEL_SRC_AUTO);
1920 - mdw->rd_signal_wait_msec =
1921 - rrddim_add(mdw->st_signal_wait_msec, "duration", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1922 - }
1923 -
1924 - rrddim_set_by_pointer(
1925 - mdw->st_signal_wait_msec,
1926 - mdw->rd_signal_wait_msec,
1927 - (collected_number)mdw->MSSQLDatabaseSignalWaitMSec.current.Data);
1928 -
1929 - rrdset_done(mdw->st_signal_wait_msec);
1930 -}
1931 -
1932 -void mssql_max_wait_charts(struct mssql_instance *mi, struct mssql_db_waits *mdw, const char *type)
1933 -{
1934 - if (unlikely(!mdw->st_max_wait_time_msec)) {
1935 - char id[RRD_ID_LENGTH_MAX + 1];
1936 -
1937 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_%s_max_wait", mi->instanceID, type);
1938 - netdata_fix_chart_name(id);
1939 - mdw->st_max_wait_time_msec = rrdset_create_localhost(
1940 - "mssql",
1941 - id,
1942 - NULL,
1943 - "locks",
1944 - "mssql.instance_max_wait_time",
1945 - "Maximum wait time for each wait type and category",
1946 - "ms",
1947 - PLUGIN_WINDOWS_NAME,
1948 - "PerflibMSSQL",
1949 - PRIO_MSSQL_MAX_WAIT_TIME,
1950 - mi->update_every,
1951 - RRDSET_TYPE_LINE);
1952 -
1953 - rrdlabels_add(mdw->st_max_wait_time_msec->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1954 - rrdlabels_add(mdw->st_max_wait_time_msec->rrdlabels, "wait_type", mdw->wait_type, RRDLABEL_SRC_AUTO);
1955 - rrdlabels_add(mdw->st_max_wait_time_msec->rrdlabels, "wait_category", mdw->wait_category, RRDLABEL_SRC_AUTO);
1956 - mdw->rd_max_wait_time_msec =
1957 - rrddim_add(mdw->st_max_wait_time_msec, "duration", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1958 - }
1959 -
1960 - rrddim_set_by_pointer(
1961 - mdw->st_max_wait_time_msec,
1962 - mdw->rd_max_wait_time_msec,
1963 - (collected_number)mdw->MSSQLDatabaseMaxWaitTimeMSec.current.Data);
1964 -
1965 - rrdset_done(mdw->st_max_wait_time_msec);
1966 -}
1967 -
1968 -void mssql_waiting_count_charts(struct mssql_instance *mi, struct mssql_db_waits *mdw, const char *type)
1969 -{
1970 - if (unlikely(!mdw->st_waiting_tasks)) {
1971 - char id[RRD_ID_LENGTH_MAX + 1];
1972 -
1973 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_%s_waiting_count", mi->instanceID, type);
1974 - netdata_fix_chart_name(id);
1975 - mdw->st_waiting_tasks = rrdset_create_localhost(
1976 - "mssql",
1977 - id,
1978 - NULL,
1979 - "locks",
1980 - "mssql.instance_waits",
1981 - "Number of waits for each wait type and category",
1982 - "waits/s",
1983 - PLUGIN_WINDOWS_NAME,
1984 - "PerflibMSSQL",
1985 - PRIO_MSSQL_WAITING_COUNT,
1986 - mi->update_every,
1987 - RRDSET_TYPE_LINE);
1988 -
1989 - rrdlabels_add(mdw->st_waiting_tasks->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
1990 - rrdlabels_add(mdw->st_waiting_tasks->rrdlabels, "wait_type", mdw->wait_type, RRDLABEL_SRC_AUTO);
1991 - rrdlabels_add(mdw->st_waiting_tasks->rrdlabels, "wait_category", mdw->wait_category, RRDLABEL_SRC_AUTO);
1992 - mdw->rd_waiting_tasks = rrddim_add(mdw->st_waiting_tasks, "waits", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1993 - }
1994 -
1995 - rrddim_set_by_pointer(
1996 - mdw->st_waiting_tasks, mdw->rd_waiting_tasks, (collected_number)mdw->MSSQLDatabaseWaitingTasks.current.Data);
1997 -
1998 - rrdset_done(mdw->st_waiting_tasks);
1999 -}
2000 -
2001 -int dict_mssql_waits_charts_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
2002 -{
2003 - const char *dimension = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
2004 - struct mssql_db_waits *mdw = value;
2005 - struct mssql_instance *mi = data;
2006 -
2007 - mssql_total_wait_charts(mi, mdw, dimension);
2008 - mssql_resource_wait_charts(mi, mdw, dimension);
2009 - mssql_signal_wait_charts(mi, mdw, dimension);
2010 - mssql_max_wait_charts(mi, mdw, dimension);
2011 - mssql_waiting_count_charts(mi, mdw, dimension);
2012 -
2013 - return 1;
2014 -}
2015 -
2016 -static void do_mssql_waits(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
2017 -{
2018 - if (unlikely(!mi->conn->collect_waits))
2019 - return;
2020 -
2021 - dictionary_sorted_walkthrough_read(mi->waits, dict_mssql_waits_charts_cb, mi);
2022 -}
2023 -
2024 -void mssql_buffman_iops_chart(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2025 -{
2026 - if (unlikely(!mdi->st_buff_page_iops)) {
2027 - char id[RRD_ID_LENGTH_MAX + 1];
2028 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_bufman_iops", mi->instanceID);
2029 - netdata_fix_chart_name(id);
2030 - mdi->st_buff_page_iops = rrdset_create_localhost(
2031 - "mssql",
2032 - id,
2033 - NULL,
2034 - "buffer cache",
2035 - "mssql.instance_bufman_iops",
2036 - "Number of pages input and output",
2037 - "pages/s",
2038 - PLUGIN_WINDOWS_NAME,
2039 - "PerflibMSSQL",
2040 - PRIO_MSSQL_BUFF_MAN_IOPS,
2041 - mi->update_every,
2042 - RRDSET_TYPE_LINE);
2043 -
2044 - mdi->rd_buff_page_reads = rrddim_add(mdi->st_buff_page_iops, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2045 - mdi->rd_buff_page_writes =
2046 - rrddim_add(mdi->st_buff_page_iops, "written", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2047 -
2048 - rrdlabels_add(mdi->st_buff_page_iops->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2049 - }
2050 -
2051 - rrddim_set_by_pointer(
2052 - mdi->st_buff_page_iops, mdi->rd_buff_page_reads, (collected_number)mdi->MSSQLBufferPageReads.current.Data);
2053 - rrddim_set_by_pointer(
2054 - mdi->st_buff_page_iops, mdi->rd_buff_page_writes, (collected_number)mdi->MSSQLBufferPageWrites.current.Data);
2055 -
2056 - rrdset_done(mdi->st_buff_page_iops);
2057 -}
2058 -
2059 -void mssql_buffman_cache_hit_ratio_chart(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2060 -{
2061 - if (unlikely(!mdi->st_buff_cache_hits)) {
2062 - char id[RRD_ID_LENGTH_MAX + 1];
2063 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_cache_hit_ratio", mi->instanceID);
2064 - netdata_fix_chart_name(id);
2065 - mdi->st_buff_cache_hits = rrdset_create_localhost(
2066 - "mssql",
2067 - id,
2068 - NULL,
2069 - "buffer cache",
2070 - "mssql.instance_cache_hit_ratio",
2071 - "Buffer Cache hit ratio",
2072 - "percentage",
2073 - PLUGIN_WINDOWS_NAME,
2074 - "PerflibMSSQL",
2075 - PRIO_MSSQL_BUFF_CACHE_HIT_RATIO,
2076 - mi->update_every,
2077 - RRDSET_TYPE_LINE);
2078 -
2079 - mdi->rd_buff_cache_hits = rrddim_add(mdi->st_buff_cache_hits, "hit_ratio", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2080 -
2081 - rrdlabels_add(mdi->st_buff_cache_hits->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2082 - }
2083 -
2084 - rrddim_set_by_pointer(
2085 - mdi->st_buff_cache_hits, mdi->rd_buff_cache_hits, (collected_number)mdi->MSSQLBufferCacheHits.current.Data);
2086 - rrdset_done(mdi->st_buff_cache_hits);
2087 -}
2088 -
2089 -void mssql_buffman_checkpoints_pages_chart(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2090 -{
2091 - if (unlikely(!mdi->st_buff_checkpoint_pages)) {
2092 - char id[RRD_ID_LENGTH_MAX + 1];
2093 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_bufman_checkpoint_pages", mi->instanceID);
2094 - netdata_fix_chart_name(id);
2095 - mdi->st_buff_checkpoint_pages = rrdset_create_localhost(
2096 - "mssql",
2097 - id,
2098 - NULL,
2099 - "buffer cache",
2100 - "mssql.instance_bufman_checkpoint_pages",
2101 - "Flushed pages",
2102 - "pages/s",
2103 - PLUGIN_WINDOWS_NAME,
2104 - "PerflibMSSQL",
2105 - PRIO_MSSQL_BUFF_CHECKPOINT_PAGES,
2106 - mi->update_every,
2107 - RRDSET_TYPE_LINE);
2108 -
2109 - mdi->rd_buff_checkpoint_pages =
2110 - rrddim_add(mdi->st_buff_checkpoint_pages, "log", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2111 -
2112 - rrdlabels_add(mdi->st_buff_checkpoint_pages->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2113 - }
2114 -
2115 - rrddim_set_by_pointer(
2116 - mdi->st_buff_checkpoint_pages,
2117 - mdi->rd_buff_checkpoint_pages,
2118 - (collected_number)mdi->MSSQLBufferCheckpointPages.current.Data);
2119 - rrdset_done(mdi->st_buff_checkpoint_pages);
2120 -}
2121 -
2122 -void mssql_buffman_page_life_expectancy_chart(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2123 -{
2124 - if (unlikely(!mdi->st_buff_cache_page_life_expectancy)) {
2125 - char id[RRD_ID_LENGTH_MAX + 1];
2126 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_bufman_page_life_expectancy", mi->instanceID);
2127 - netdata_fix_chart_name(id);
2128 - mdi->st_buff_cache_page_life_expectancy = rrdset_create_localhost(
2129 - "mssql",
2130 - id,
2131 - NULL,
2132 - "buffer cache",
2133 - "mssql.instance_bufman_page_life_expectancy",
2134 - "Page life expectancy",
2135 - "seconds",
2136 - PLUGIN_WINDOWS_NAME,
2137 - "PerflibMSSQL",
2138 - PRIO_MSSQL_BUFF_PAGE_LIFE_EXPECTANCY,
2139 - mi->update_every,
2140 - RRDSET_TYPE_LINE);
2141 -
2142 - mdi->rd_buff_cache_page_life_expectancy =
2143 - rrddim_add(mdi->st_buff_cache_page_life_expectancy, "life_expectancy", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2144 -
2145 - rrdlabels_add(
2146 - mdi->st_buff_cache_page_life_expectancy->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2147 - }
2148 -
2149 - rrddim_set_by_pointer(
2150 - mdi->st_buff_cache_page_life_expectancy,
2151 - mdi->rd_buff_cache_page_life_expectancy,
2152 - (collected_number)mdi->MSSQLBufferPageLifeExpectancy.current.Data);
2153 - rrdset_done(mdi->st_buff_cache_page_life_expectancy);
2154 -}
2155 -
2156 -void mssql_buffman_lazy_write_chart(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2157 -{
2158 - if (unlikely(!mdi->st_buff_lazy_write)) {
2159 - char id[RRD_ID_LENGTH_MAX + 1];
2160 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_bufman_lazy_write", mi->instanceID);
2161 - netdata_fix_chart_name(id);
2162 - mdi->st_buff_lazy_write = rrdset_create_localhost(
2163 - "mssql",
2164 - id,
2165 - NULL,
2166 - "buffer cache",
2167 - "mssql.instance_bufman_lazy_write",
2168 - "Buffers written by buffer manager's lazy writer",
2169 - "writes/s",
2170 - PLUGIN_WINDOWS_NAME,
2171 - "PerflibMSSQL",
2172 - PRIO_MSSQL_BUFF_LAZY_WRITE,
2173 - mi->update_every,
2174 - RRDSET_TYPE_LINE);
2175 -
2176 - mdi->rd_buff_lazy_write = rrddim_add(mdi->st_buff_lazy_write, "writes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2177 -
2178 - rrdlabels_add(mdi->st_buff_lazy_write->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2179 - }
2180 -
2181 - rrddim_set_by_pointer(
2182 - mdi->st_buff_lazy_write, mdi->rd_buff_lazy_write, (collected_number)mdi->MSSQLBufferLazyWrite.current.Data);
2183 - rrdset_done(mdi->st_buff_lazy_write);
2184 -}
2185 -
2186 -void mssql_buffman_page_lookups_chart(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2187 -{
2188 - if (unlikely(!mdi->st_buff_page_lookups)) {
2189 - char id[RRD_ID_LENGTH_MAX + 1];
2190 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_bufman_page_lookups", mi->instanceID);
2191 - netdata_fix_chart_name(id);
2192 - mdi->st_buff_page_lookups = rrdset_create_localhost(
2193 - "mssql",
2194 - id,
2195 - NULL,
2196 - "buffer cache",
2197 - "mssql.instance_bufman_page_lookups",
2198 - "Requests to find a page in the buffer pool.",
2199 - "lookups/s",
2200 - PLUGIN_WINDOWS_NAME,
2201 - "PerflibMSSQL",
2202 - PRIO_MSSQL_BUFF_PAGE_LOOKUPS,
2203 - mi->update_every,
2204 - RRDSET_TYPE_LINE);
2205 -
2206 - mdi->rd_buff_page_lookups =
2207 - rrddim_add(mdi->st_buff_page_lookups, "lookups", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2208 -
2209 - rrdlabels_add(mdi->st_buff_page_lookups->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2210 - }
2211 -
2212 - rrddim_set_by_pointer(
2213 - mdi->st_buff_page_lookups,
2214 - mdi->rd_buff_page_lookups,
2215 - (collected_number)mdi->MSSQLBufferPageLookups.current.Data);
2216 - rrdset_done(mdi->st_buff_page_lookups);
2217 -}
2218 -
2219 -static void netdata_mssql_compilations(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2220 -{
2221 - if (unlikely(!mdi->st_stats_compilation)) {
2222 - char id[RRD_ID_LENGTH_MAX + 1];
2223 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_sqlstats_sql_compilations", mi->instanceID);
2224 - netdata_fix_chart_name(id);
2225 - mdi->st_stats_compilation = rrdset_create_localhost(
2226 - "mssql",
2227 - id,
2228 - NULL,
2229 - "sql activity",
2230 - "mssql.instance_sqlstats_sql_compilations",
2231 - "SQL compilations",
2232 - "compilations/s",
2233 - PLUGIN_WINDOWS_NAME,
2234 - "PerflibMSSQL",
2235 - PRIO_MSSQL_STATS_COMPILATIONS,
2236 - mi->update_every,
2237 - RRDSET_TYPE_LINE);
2238 -
2239 - mdi->rd_stats_compilation =
2240 - rrddim_add(mdi->st_stats_compilation, "compilations", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2241 -
2242 - rrdlabels_add(mdi->st_stats_compilation->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2243 - }
2244 -
2245 - rrddim_set_by_pointer(
2246 - mdi->st_stats_compilation, mdi->rd_stats_compilation, (collected_number)mdi->MSSQLCompilations.current.Data);
2247 - rrdset_done(mdi->st_stats_compilation);
2248 -}
2249 -
2250 -static void netdata_mssql_recompilations(struct mssql_db_instance *mdi, struct mssql_instance *mi)
2251 -{
2252 - if (unlikely(!mdi->st_stats_recompiles)) {
2253 - char id[RRD_ID_LENGTH_MAX + 1];
2254 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_sqlstats_sql_recompilations", mi->instanceID);
2255 - netdata_fix_chart_name(id);
2256 - mdi->st_stats_recompiles = rrdset_create_localhost(
2257 - "mssql",
2258 - id,
2259 - NULL,
2260 - "sql activity",
2261 - "mssql.instance_sqlstats_sql_recompilations",
2262 - "SQL re-compilations",
2263 - "recompiles/s",
2264 - PLUGIN_WINDOWS_NAME,
2265 - "PerflibMSSQL",
2266 - PRIO_MSSQL_STATS_RECOMPILATIONS,
2267 - mi->update_every,
2268 - RRDSET_TYPE_LINE);
2269 -
2270 - mdi->rd_stats_recompiles =
2271 - rrddim_add(mdi->st_stats_recompiles, "recompiles", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2272 -
2273 - rrdlabels_add(mdi->st_stats_recompiles->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2274 - }
2275 -
2276 - rrddim_set_by_pointer(
2277 - mdi->st_stats_recompiles, mdi->rd_stats_recompiles, (collected_number)mdi->MSSQLRecompilations.current.Data);
2278 - rrdset_done(mdi->st_stats_recompiles);
2279 -}
2280 -
2281 -int dict_mssql_buffman_stats_charts_cb(
2282 - const DICTIONARY_ITEM *item __maybe_unused,
2283 - void *value,
2284 - void *data __maybe_unused)
2285 -{
2286 - struct mssql_db_instance *mdi = value;
2287 - struct mssql_instance *mi = data;
2288 -
2289 - if (unlikely(!mdi->collect_instance))
2290 - return 1;
2291 -
2292 - mssql_buffman_iops_chart(mdi, mi);
2293 - mssql_buffman_cache_hit_ratio_chart(mdi, mi);
2294 - mssql_buffman_checkpoints_pages_chart(mdi, mi);
2295 - mssql_buffman_page_life_expectancy_chart(mdi, mi);
2296 - mssql_buffman_lazy_write_chart(mdi, mi);
2297 - mssql_buffman_page_lookups_chart(mdi, mi);
2298 -
2299 - netdata_mssql_compilations(mdi, mi);
2300 - netdata_mssql_recompilations(mdi, mi);
2301 -
2302 - return 1;
2303 -}
2304 -
2305 -static void do_mssql_bufferman_stats_sql(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
2306 -{
2307 - if (unlikely(!mi->conn->collect_buffer))
2308 - return;
2309 -
2310 - dictionary_sorted_walkthrough_read(mi->databases, dict_mssql_buffman_stats_charts_cb, mi);
2311 -}
2312 -
2313 -static void netdata_mssql_jobs_status(struct mssql_db_jobs *mdj, struct mssql_instance *mi, const char *job)
2314 -{
2315 - if (unlikely(!mdj->st_status)) {
2316 - char id[RRD_ID_LENGTH_MAX + 1];
2317 - snprintfz(id, RRD_ID_LENGTH_MAX, "job_%s_instance_%s_status", job, mi->instanceID);
2318 - netdata_fix_chart_name(id);
2319 - mdj->st_status = rrdset_create_localhost(
2320 - "mssql",
2321 - id,
2322 - NULL,
2323 - "jobs",
2324 - "mssql.instance_jobs_status",
2325 - "Jobs running",
2326 - "status",
2327 - PLUGIN_WINDOWS_NAME,
2328 - "PerflibMSSQL",
2329 - PRIO_MSSQL_DATABASE_JOBS_STATUS,
2330 - mi->update_every,
2331 - RRDSET_TYPE_LINE);
2332 -
2333 - mdj->rd_status_enabled = rrddim_add(mdj->st_status, "enabled", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2334 -
2335 - mdj->rd_status_disabled = rrddim_add(mdj->st_status, "disabled", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2336 -
2337 - rrdlabels_add(mdj->st_status->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
2338 - rrdlabels_add(mdj->st_status->rrdlabels, "job_name", job, RRDLABEL_SRC_AUTO);
2339 - }
2340 -
2341 - rrddim_set_by_pointer(
2342 - mdj->st_status, mdj->rd_status_enabled, (collected_number)(mdj->MSSQLJOBState.current.Data == 1));
2343 - rrddim_set_by_pointer(
2344 - mdj->st_status, mdj->rd_status_disabled, (collected_number)(mdj->MSSQLJOBState.current.Data == 0));
2345 - rrdset_done(mdj->st_status);
2346 -}
2347 -
2348 -int dict_mssql_sysjobs_chart_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
2349 -{
2350 - const char *job = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
2351 - struct mssql_db_jobs *mdj = value;
2352 - struct mssql_instance *mi = data;
2353 -
2354 - netdata_mssql_jobs_status(mdj, mi, job);
2355 -}
2356 -
2357 -static void do_mssql_job_status_sql(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
2358 -{
2359 - if (unlikely(!mi->conn->collect_jobs))
2360 - return;
2361 -
2362 - dictionary_sorted_walkthrough_read(mi->sysjobs, dict_mssql_sysjobs_chart_cb, mi);
2363 -}
2364 -
2365 -static void do_mssql_user_connection(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
2366 -{
2367 - if (unlikely(!mi->conn->collect_user_connections))
2368 - return;
2369 -
2370 - do_mssql_user_connections(mi, update_every);
2371 - do_mssql_sessions_connections(mi, update_every);
2372 -}
2373 -
2374 -void dict_mssql_replication_status(struct mssql_publisher_publication *mpp, int update_every)
2375 -{
2376 - if (unlikely(!mpp->st_publisher_status)) {
2377 - char id[RRD_ID_LENGTH_MAX + 1];
2378 -
2379 - snprintfz(
2380 - id,
2381 - RRD_ID_LENGTH_MAX,
2382 - "instance_%s_replication_%s_%s_status",
2383 - mpp->parent->instanceID,
2384 - mpp->publication,
2385 - mpp->db);
2386 - netdata_fix_chart_name(id);
2387 - mpp->st_publisher_status = rrdset_create_localhost(
2388 - "mssql",
2389 - id,
2390 - NULL,
2391 - "replication",
2392 - "mssql.replication_status",
2393 - "Current replication status",
2394 - "status",
2395 - PLUGIN_WINDOWS_NAME,
2396 - "PerflibMSSQL",
2397 - PRIO_MSSQL_REPLICATION_STATUS,
2398 - update_every,
2399 - RRDSET_TYPE_LINE);
2400 -
2401 - rrdlabels_add(
2402 - mpp->st_publisher_status->rrdlabels, "mssql_instance", mpp->parent->instanceID, RRDLABEL_SRC_AUTO);
2403 - rrdlabels_add(mpp->st_publisher_status->rrdlabels, "publisher", mpp->publisher, RRDLABEL_SRC_AUTO);
2404 - rrdlabels_add(mpp->st_publisher_status->rrdlabels, "database", mpp->db, RRDLABEL_SRC_AUTO);
2405 - rrdlabels_add(mpp->st_publisher_status->rrdlabels, "publication", mpp->publication, RRDLABEL_SRC_AUTO);
2406 -
2407 - mpp->rd_publisher_status_started =
2408 - rrddim_add(mpp->st_publisher_status, "started", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2409 - mpp->rd_publisher_status_successed =
2410 - rrddim_add(mpp->st_publisher_status, "succeeded", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2411 - mpp->rd_publisher_status_in_progress =
2412 - rrddim_add(mpp->st_publisher_status, "in_progress", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2413 - mpp->rd_publisher_status_idle =
2414 - rrddim_add(mpp->st_publisher_status, "idle", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2415 - mpp->rd_publisher_status_retrying =
2416 - rrddim_add(mpp->st_publisher_status, "retrying", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2417 - mpp->rd_publisher_status_failed =
2418 - rrddim_add(mpp->st_publisher_status, "failed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2419 - }
2420 -
2421 - int status = mpp->status;
2422 - rrddim_set_by_pointer(mpp->st_publisher_status, mpp->rd_publisher_status_started, (collected_number)(status == 1));
2423 - rrddim_set_by_pointer(
2424 - mpp->st_publisher_status, mpp->rd_publisher_status_successed, (collected_number)(status == 2));
2425 - rrddim_set_by_pointer(
2426 - mpp->st_publisher_status, mpp->rd_publisher_status_in_progress, (collected_number)(status == 3));
2427 - rrddim_set_by_pointer(mpp->st_publisher_status, mpp->rd_publisher_status_idle, (collected_number)(status == 4));
2428 - rrddim_set_by_pointer(mpp->st_publisher_status, mpp->rd_publisher_status_retrying, (collected_number)(status == 5));
2429 - rrddim_set_by_pointer(mpp->st_publisher_status, mpp->rd_publisher_status_failed, (collected_number)(status == 6));
2430 - rrdset_done(mpp->st_publisher_status);
2431 -}
2432 -
2433 -void dict_mssql_replication_warning(struct mssql_publisher_publication *mpp, int update_every)
2434 -{
2435 - if (unlikely(!mpp->st_warning)) {
2436 - char id[RRD_ID_LENGTH_MAX + 1];
2437 -
2438 - snprintfz(
2439 - id,
2440 - RRD_ID_LENGTH_MAX,
2441 - "instance_%s_replication_%s_%s_warning",
2442 - mpp->parent->instanceID,
2443 - mpp->publication,
2444 - mpp->db);
2445 - netdata_fix_chart_name(id);
2446 - mpp->st_warning = rrdset_create_localhost(
2447 - "mssql",
2448 - id,
2449 - NULL,
2450 - "replication",
2451 - "mssql.replication_warning",
2452 - "Maximum threshold warning.",
2453 - "status",
2454 - PLUGIN_WINDOWS_NAME,
2455 - "PerflibMSSQL",
2456 - PRIO_MSSQL_REPLICATION_WARNING,
2457 - update_every,
2458 - RRDSET_TYPE_LINE);
2459 -
2460 - rrdlabels_add(mpp->st_warning->rrdlabels, "mssql_instance", mpp->parent->instanceID, RRDLABEL_SRC_AUTO);
2461 - rrdlabels_add(mpp->st_warning->rrdlabels, "publisher", mpp->publisher, RRDLABEL_SRC_AUTO);
2462 - rrdlabels_add(mpp->st_warning->rrdlabels, "database", mpp->db, RRDLABEL_SRC_AUTO);
2463 - rrdlabels_add(mpp->st_warning->rrdlabels, "publication", mpp->publication, RRDLABEL_SRC_AUTO);
2464 -
2465 - mpp->rd_warning_expiration = rrddim_add(mpp->st_warning, "expiration", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2466 - mpp->rd_warning_latency = rrddim_add(mpp->st_warning, "latency", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2467 - mpp->rd_warning_mergeeexpiration =
2468 - rrddim_add(mpp->st_warning, "merge expiration", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2469 - mpp->rd_warning_mergefastduration =
2470 - rrddim_add(mpp->st_warning, "fast duration", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2471 - mpp->rd_warning_mergelowduration =
2472 - rrddim_add(mpp->st_warning, "low duration", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2473 - mpp->rd_warning_mergefastrunspeed =
2474 - rrddim_add(mpp->st_warning, "fast run speed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2475 - mpp->rd_warning_mergelowrunspeed =
2476 - rrddim_add(mpp->st_warning, "low run speed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2477 - }
2478 -
2479 - int warning = mpp->warning;
2480 - rrddim_set_by_pointer(
2481 - mpp->st_warning, mpp->rd_warning_expiration, (collected_number)(warning & MSSQL_REPLICATON_EXPIRATION));
2482 - rrddim_set_by_pointer(
2483 - mpp->st_warning, mpp->rd_warning_latency, (collected_number)(warning & MSSQL_REPLICATON_LATENCY));
2484 - rrddim_set_by_pointer(
2485 - mpp->st_warning,
2486 - mpp->rd_warning_mergeeexpiration,
2487 - (collected_number)(warning & MSSQL_REPLICATON_MERGEEXPIRATION));
2488 - rrddim_set_by_pointer(
2489 - mpp->st_warning,
2490 - mpp->rd_warning_mergefastduration,
2491 - (collected_number)(warning & MSSQL_REPLICATON_MERGEFASTDURATION));
2492 - rrddim_set_by_pointer(
2493 - mpp->st_warning,
2494 - mpp->rd_warning_mergelowduration,
2495 - (collected_number)(warning & MSSQL_REPLICATON_MERGELOWDURATION));
2496 - rrddim_set_by_pointer(
2497 - mpp->st_warning,
2498 - mpp->rd_warning_mergefastrunspeed,
2499 - (collected_number)(warning & MSSQL_REPLICATON_MERGEFASTRUNSPEED));
2500 - rrddim_set_by_pointer(
2501 - mpp->st_warning,
2502 - mpp->rd_warning_mergelowrunspeed,
2503 - (collected_number)(warning & MSSQL_REPLICATON_MERGELOWRUNSPEED));
2504 - rrdset_done(mpp->st_warning);
2505 -}
2506 -
2507 -void dict_mssql_replication_avg_latency(struct mssql_publisher_publication *mpp, int update_every)
2508 -{
2509 - if (unlikely(!mpp->st_avg_latency)) {
2510 - char id[RRD_ID_LENGTH_MAX + 1];
2511 -
2512 - snprintfz(
2513 - id,
2514 - RRD_ID_LENGTH_MAX,
2515 - "instance_%s_replication_%s_%s_avg_latency",
2516 - mpp->parent->instanceID,
2517 - mpp->publication,
2518 - mpp->db);
2519 - netdata_fix_chart_name(id);
2520 - mpp->st_avg_latency = rrdset_create_localhost(
2521 - "mssql",
2522 - id,
2523 - NULL,
2524 - "replication",
2525 - "mssql.replication_avg_latency",
2526 - "Average latency for a transactional publication.",
2527 - "seconds",
2528 - PLUGIN_WINDOWS_NAME,
2529 - "PerflibMSSQL",
2530 - PRIO_MSSQL_REPLICATION_AVG_LATENCY,
2531 - update_every,
2532 - RRDSET_TYPE_LINE);
2533 -
2534 - rrdlabels_add(mpp->st_avg_latency->rrdlabels, "mssql_instance", mpp->parent->instanceID, RRDLABEL_SRC_AUTO);
2535 - rrdlabels_add(mpp->st_avg_latency->rrdlabels, "publisher", mpp->publisher, RRDLABEL_SRC_AUTO);
2536 - rrdlabels_add(mpp->st_avg_latency->rrdlabels, "database", mpp->db, RRDLABEL_SRC_AUTO);
2537 - rrdlabels_add(mpp->st_avg_latency->rrdlabels, "publication", mpp->publication, RRDLABEL_SRC_AUTO);
2538 -
2539 - mpp->rd_avg_latency = rrddim_add(mpp->st_avg_latency, "latency", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2540 - }
2541 -
2542 - rrddim_set_by_pointer(mpp->st_avg_latency, mpp->rd_avg_latency, (collected_number)mpp->avg_latency);
2543 - rrdset_done(mpp->st_avg_latency);
2544 -}
2545 -
2546 -void dict_mssql_replication_subscription(struct mssql_publisher_publication *mpp, int update_every)
2547 -{
2548 - if (unlikely(!mpp->st_subscription_count)) {
2549 - char id[RRD_ID_LENGTH_MAX + 1];
2550 -
2551 - snprintfz(
2552 - id,
2553 - RRD_ID_LENGTH_MAX,
2554 - "instance_%s_replication_%s_%s_subscription",
2555 - mpp->parent->instanceID,
2556 - mpp->publication,
2557 - mpp->db);
2558 - netdata_fix_chart_name(id);
2559 - mpp->st_subscription_count = rrdset_create_localhost(
2560 - "mssql",
2561 - id,
2562 - NULL,
2563 - "replication",
2564 - "mssql.replication_subscription",
2565 - "Number of subscriptions to a publication.",
2566 - "subscription",
2567 - PLUGIN_WINDOWS_NAME,
2568 - "PerflibMSSQL",
2569 - PRIO_MSSQL_REPLICATION_SUBSCRIPTION_COUNT,
2570 - update_every,
2571 - RRDSET_TYPE_LINE);
2572 -
2573 - rrdlabels_add(
2574 - mpp->st_subscription_count->rrdlabels, "mssql_instance", mpp->parent->instanceID, RRDLABEL_SRC_AUTO);
2575 - rrdlabels_add(mpp->st_subscription_count->rrdlabels, "publisher", mpp->publisher, RRDLABEL_SRC_AUTO);
2576 - rrdlabels_add(mpp->st_subscription_count->rrdlabels, "database", mpp->db, RRDLABEL_SRC_AUTO);
2577 - rrdlabels_add(mpp->st_subscription_count->rrdlabels, "publication", mpp->publication, RRDLABEL_SRC_AUTO);
2578 -
2579 - mpp->rd_subscription_count =
2580 - rrddim_add(mpp->st_subscription_count, "subscription", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2581 - }
2582 -
2583 - rrddim_set_by_pointer(
2584 - mpp->st_subscription_count, mpp->rd_subscription_count, (collected_number)mpp->subscriptioncount);
2585 - rrdset_done(mpp->st_subscription_count);
2586 -}
2587 -
2588 -void dict_mssql_replication_dist_agent_running(struct mssql_publisher_publication *mpp, int update_every)
2589 -{
2590 - if (unlikely(!mpp->st_running_agent)) {
2591 - char id[RRD_ID_LENGTH_MAX + 1];
2592 -
2593 - snprintfz(
2594 - id,
2595 - RRD_ID_LENGTH_MAX,
2596 - "instance_%s_replication_%s_%s_agent_running",
2597 - mpp->parent->instanceID,
2598 - mpp->publication,
2599 - mpp->db);
2600 - netdata_fix_chart_name(id);
2601 - mpp->st_running_agent = rrdset_create_localhost(
2602 - "mssql",
2603 - id,
2604 - NULL,
2605 - "replication",
2606 - "mssql.replication_agent_running",
2607 - "Distribution agents running.",
2608 - "agents",
2609 - PLUGIN_WINDOWS_NAME,
2610 - "PerflibMSSQL",
2611 - PRIO_MSSQL_REPLICATION_AGENT_RUNNING,
2612 - update_every,
2613 - RRDSET_TYPE_LINE);
2614 -
2615 - rrdlabels_add(mpp->st_running_agent->rrdlabels, "mssql_instance", mpp->parent->instanceID, RRDLABEL_SRC_AUTO);
2616 - rrdlabels_add(mpp->st_running_agent->rrdlabels, "publisher", mpp->publisher, RRDLABEL_SRC_AUTO);
2617 - rrdlabels_add(mpp->st_running_agent->rrdlabels, "database", mpp->db, RRDLABEL_SRC_AUTO);
2618 - rrdlabels_add(mpp->st_running_agent->rrdlabels, "publication", mpp->publication, RRDLABEL_SRC_AUTO);
2619 -
2620 - mpp->rd_running_agent = rrddim_add(mpp->st_running_agent, "agents", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2621 - }
2622 -
2623 - rrddim_set_by_pointer(mpp->st_running_agent, mpp->rd_running_agent, (collected_number)mpp->runningdistagentcount);
2624 - rrdset_done(mpp->st_running_agent);
2625 -}
2626 -
2627 -void dict_mssql_replication_sync_time(struct mssql_publisher_publication *mpp, int update_every)
2628 -{
2629 - if (unlikely(!mpp->st_synchronization_time)) {
2630 - char id[RRD_ID_LENGTH_MAX + 1];
2631 -
2632 - snprintfz(
2633 - id,
2634 - RRD_ID_LENGTH_MAX,
2635 - "instance_%s_replication_%s_%s_synchronization",
2636 - mpp->parent->instanceID,
2637 - mpp->publication,
2638 - mpp->db);
2639 - netdata_fix_chart_name(id);
2640 - mpp->st_synchronization_time = rrdset_create_localhost(
2641 - "mssql",
2642 - id,
2643 - NULL,
2644 - "replication",
2645 - "mssql.replication_synchronization",
2646 - "The shortest synchronization.",
2647 - "seconds",
2648 - PLUGIN_WINDOWS_NAME,
2649 - "PerflibMSSQL",
2650 - PRIO_MSSQL_REPLICATION_SYNC_TIME,
2651 - update_every,
2652 - RRDSET_TYPE_LINE);
2653 -
2654 - rrdlabels_add(
2655 - mpp->st_synchronization_time->rrdlabels, "mssql_instance", mpp->parent->instanceID, RRDLABEL_SRC_AUTO);
2656 - rrdlabels_add(mpp->st_synchronization_time->rrdlabels, "publisher", mpp->publisher, RRDLABEL_SRC_AUTO);
2657 - rrdlabels_add(mpp->st_synchronization_time->rrdlabels, "database", mpp->db, RRDLABEL_SRC_AUTO);
2658 - rrdlabels_add(mpp->st_synchronization_time->rrdlabels, "publication", mpp->publication, RRDLABEL_SRC_AUTO);
2659 -
2660 - mpp->rd_synchronization_time =
2661 - rrddim_add(mpp->st_synchronization_time, "seconds", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2662 - }
2663 -
2664 - rrddim_set_by_pointer(
2665 - mpp->st_synchronization_time, mpp->rd_synchronization_time, (collected_number)mpp->runningdistagentcount);
2666 - rrdset_done(mpp->st_synchronization_time);
2667 -}
2668 -
2669 -int dict_mssql_replication_chart_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
2670 -{
2671 - struct mssql_publisher_publication *mpp = value;
2672 - int *update_every = data;
2673 -
2674 - dict_mssql_replication_status(mpp, *update_every);
2675 - dict_mssql_replication_warning(mpp, *update_every);
2676 - dict_mssql_replication_avg_latency(mpp, *update_every);
2677 - dict_mssql_replication_subscription(mpp, *update_every);
2678 - dict_mssql_replication_dist_agent_running(mpp, *update_every);
2679 - dict_mssql_replication_sync_time(mpp, *update_every);
2680 -}
2681 -
2682 -static void do_mssql_replication(struct mssql_instance *mi, int update_every)
2683 -{
2684 - if (unlikely(!mi->conn->collect_replication))
2685 - return;
2686 -
2687 - dictionary_sorted_walkthrough_read(mi->publisher_publication, dict_mssql_replication_chart_cb, &update_every);
2688 -}
2689 -
2690 -static void mssql_database_backup_restore_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2691 -{
2692 - if (unlikely(!mdi->st_db_backup_restore_operations)) {
2693 - char id[RRD_ID_LENGTH_MAX + 1];
2694 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_backup_restore_operations", db, mdi->parent->instanceID);
2695 - netdata_fix_chart_name(id);
2696 - mdi->st_db_backup_restore_operations = rrdset_create_localhost(
2697 - "mssql",
2698 - id,
2699 - NULL,
2700 - "transactions",
2701 - "mssql.database_backup_restore_operations",
2702 - "Backup IO per database",
2703 - "operations/s",
2704 - PLUGIN_WINDOWS_NAME,
2705 - "PerflibMSSQL",
2706 - PRIO_MSSQL_DATABASE_BACKUP_RESTORE_OPERATIONS,
2707 - update_every,
2708 - RRDSET_TYPE_LINE);
2709 -
2710 - rrdlabels_add(
2711 - mdi->st_db_backup_restore_operations->rrdlabels,
2712 - "mssql_instance",
2713 - mdi->parent->instanceID,
2714 - RRDLABEL_SRC_AUTO);
2715 - rrdlabels_add(mdi->st_db_backup_restore_operations->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2716 -
2717 - mdi->rd_db_backup_restore_operations =
2718 - rrddim_add(mdi->st_db_backup_restore_operations, "backup", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2719 - }
2720 -
2721 - rrddim_set_by_pointer(
2722 - mdi->st_db_backup_restore_operations,
2723 - mdi->rd_db_backup_restore_operations,
2724 - (collected_number)mdi->MSSQLDatabaseBackupRestoreOperations.current.Data);
2725 -
2726 - rrdset_done(mdi->st_db_backup_restore_operations);
2727 -}
2728 -
2729 -static void mssql_database_log_flushes_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2730 -{
2731 - if (unlikely(!mdi->st_db_log_flushes)) {
2732 - char id[RRD_ID_LENGTH_MAX + 1];
2733 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_log_flushes", db, mdi->parent->instanceID);
2734 - netdata_fix_chart_name(id);
2735 - mdi->st_db_log_flushes = rrdset_create_localhost(
2736 - "mssql",
2737 - id,
2738 - NULL,
2739 - "transactions",
2740 - "mssql.database_log_flushes",
2741 - "Log flushes",
2742 - "flushes/s",
2743 - PLUGIN_WINDOWS_NAME,
2744 - "PerflibMSSQL",
2745 - PRIO_MSSQL_DATABASE_LOG_FLUSHES,
2746 - update_every,
2747 - RRDSET_TYPE_LINE);
2748 -
2749 - rrdlabels_add(mdi->st_db_log_flushes->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2750 - rrdlabels_add(mdi->st_db_log_flushes->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2751 - }
2752 -
2753 - if (unlikely(!mdi->rd_db_log_flushes)) {
2754 - mdi->rd_db_log_flushes = rrddim_add(mdi->st_db_log_flushes, "flushes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2755 - }
2756 -
2757 - rrddim_set_by_pointer(
2758 - mdi->st_db_log_flushes, mdi->rd_db_log_flushes, (collected_number)mdi->MSSQLDatabaseLogFlushes.current.Data);
2759 -
2760 - rrdset_done(mdi->st_db_log_flushes);
2761 -}
2762 -
2763 -static void mssql_database_log_flushed_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2764 -{
2765 - if (unlikely(!mdi->st_db_log_flushed)) {
2766 - char id[RRD_ID_LENGTH_MAX + 1];
2767 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_log_flushed", db, mdi->parent->instanceID);
2768 - netdata_fix_chart_name(id);
2769 - mdi->st_db_log_flushed = rrdset_create_localhost(
2770 - "mssql",
2771 - id,
2772 - NULL,
2773 - "transactions",
2774 - "mssql.database_log_flushed",
2775 - "Log flushed",
2776 - "bytes/s",
2777 - PLUGIN_WINDOWS_NAME,
2778 - "PerflibMSSQL",
2779 - PRIO_MSSQL_DATABASE_LOG_FLUSHED,
2780 - update_every,
2781 - RRDSET_TYPE_LINE);
2782 -
2783 - rrdlabels_add(mdi->st_db_log_flushed->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2784 - rrdlabels_add(mdi->st_db_log_flushed->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2785 -
2786 - mdi->rd_db_log_flushed = rrddim_add(mdi->st_db_log_flushed, "flushed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2787 - }
2788 -
2789 - rrddim_set_by_pointer(
2790 - mdi->st_db_log_flushed, mdi->rd_db_log_flushed, (collected_number)mdi->MSSQLDatabaseLogFlushed.current.Data);
2791 -
2792 - rrdset_done(mdi->st_db_log_flushed);
2793 -}
2794 -
2795 -static void mssql_transactions_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2796 -{
2797 - if (unlikely(!mdi->st_db_transactions)) {
2798 - char id[RRD_ID_LENGTH_MAX + 1];
2799 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_transactions", db, mdi->parent->instanceID);
2800 - netdata_fix_chart_name(id);
2801 - mdi->st_db_transactions = rrdset_create_localhost(
2802 - "mssql",
2803 - id,
2804 - NULL,
2805 - "transactions",
2806 - "mssql.database_transactions",
2807 - "Transactions",
2808 - "transactions/s",
2809 - PLUGIN_WINDOWS_NAME,
2810 - "PerflibMSSQL",
2811 - PRIO_MSSQL_DATABASE_TRANSACTIONS,
2812 - update_every,
2813 - RRDSET_TYPE_LINE);
2814 -
2815 - rrdlabels_add(mdi->st_db_transactions->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2816 - rrdlabels_add(mdi->st_db_transactions->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2817 -
2818 - mdi->rd_db_transactions =
2819 - rrddim_add(mdi->st_db_transactions, "transactions", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2820 - }
2821 -
2822 - rrddim_set_by_pointer(
2823 - mdi->st_db_transactions,
2824 - mdi->rd_db_transactions,
2825 - (collected_number)mdi->MSSQLDatabaseTransactions.current.Data);
2826 -
2827 - rrdset_done(mdi->st_db_transactions);
2828 -}
2829 -
2830 -static void mssql_write_transactions_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2831 -{
2832 - if (unlikely(!mdi->st_db_write_transactions)) {
2833 - char id[RRD_ID_LENGTH_MAX + 1];
2834 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_write_transactions", db, mdi->parent->instanceID);
2835 - netdata_fix_chart_name(id);
2836 - mdi->st_db_write_transactions = rrdset_create_localhost(
2837 - "mssql",
2838 - id,
2839 - NULL,
2840 - "transactions",
2841 - "mssql.database_write_transactions",
2842 - "Write transactions",
2843 - "transactions/s",
2844 - PLUGIN_WINDOWS_NAME,
2845 - "PerflibMSSQL",
2846 - PRIO_MSSQL_DATABASE_WRITE_TRANSACTIONS,
2847 - update_every,
2848 - RRDSET_TYPE_LINE);
2849 -
2850 - rrdlabels_add(
2851 - mdi->st_db_write_transactions->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2852 - rrdlabels_add(mdi->st_db_write_transactions->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2853 -
2854 - mdi->rd_db_write_transactions =
2855 - rrddim_add(mdi->st_db_write_transactions, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2856 - }
2857 -
2858 - rrddim_set_by_pointer(
2859 - mdi->st_db_write_transactions,
2860 - mdi->rd_db_write_transactions,
2861 - (collected_number)mdi->MSSQLDatabaseWriteTransactions.current.Data);
2862 -
2863 - rrdset_done(mdi->st_db_write_transactions);
2864 -}
2865 -
2866 -static void mssql_lockwait_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2867 -{
2868 - if (unlikely(!mdi->st_db_lockwait)) {
2869 - char id[RRD_ID_LENGTH_MAX + 1];
2870 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_lockwait", db, mdi->parent->instanceID);
2871 - netdata_fix_chart_name(id);
2872 - mdi->st_db_lockwait = rrdset_create_localhost(
2873 - "mssql",
2874 - id,
2875 - NULL,
2876 - "locks",
2877 - "mssql.database_lockwait",
2878 - "Lock requests that required the caller to wait.",
2879 - "locks/s",
2880 - PLUGIN_WINDOWS_NAME,
2881 - "PerflibMSSQL",
2882 - PRIO_MSSQL_DATABASE_LOCKWAIT_PER_SECOND,
2883 - update_every,
2884 - RRDSET_TYPE_LINE);
2885 -
2886 - rrdlabels_add(mdi->st_db_lockwait->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2887 - rrdlabels_add(mdi->st_db_lockwait->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2888 -
2889 - mdi->rd_db_lockwait = rrddim_add(mdi->st_db_lockwait, "lock", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2890 - }
2891 -
2892 - rrddim_set_by_pointer(
2893 - mdi->st_db_lockwait, mdi->rd_db_lockwait, (collected_number)mdi->MSSQLDatabaseLockWaitSec.current.Data);
2894 -
2895 - rrdset_done(mdi->st_db_lockwait);
2896 -}
2897 -
2898 -static void mssql_deadlock_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2899 -{
2900 - if (unlikely(!mdi->st_db_deadlock)) {
2901 - char id[RRD_ID_LENGTH_MAX + 1];
2902 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_deadlocks", db, mdi->parent->instanceID);
2903 - netdata_fix_chart_name(id);
2904 - mdi->st_db_deadlock = rrdset_create_localhost(
2905 - "mssql",
2906 - id,
2907 - NULL,
2908 - "locks",
2909 - "mssql.database_deadlocks",
2910 - "Lock requests that resulted in deadlock.",
2911 - "deadlocks/s",
2912 - PLUGIN_WINDOWS_NAME,
2913 - "PerflibMSSQL",
2914 - PRIO_MSSQL_DATABASE_DEADLOCKS_PER_SECOND,
2915 - update_every,
2916 - RRDSET_TYPE_LINE);
2917 -
2918 - rrdlabels_add(mdi->st_db_deadlock->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2919 - rrdlabels_add(mdi->st_db_deadlock->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2920 -
2921 - mdi->rd_db_deadlock = rrddim_add(mdi->st_db_deadlock, "deadlocks", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2922 - }
2923 -
2924 - rrddim_set_by_pointer(
2925 - mdi->st_db_deadlock, mdi->rd_db_deadlock, (collected_number)mdi->MSSQLDatabaseDeadLockSec.current.Data);
2926 -
2927 - rrdset_done(mdi->st_db_deadlock);
2928 -}
2929 -
2930 -static void mssql_is_readonly_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2931 -{
2932 - if (unlikely(!mdi->st_db_readonly)) {
2933 - char id[RRD_ID_LENGTH_MAX + 1];
2934 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_readonly", db, mdi->parent->instanceID);
2935 - netdata_fix_chart_name(id);
2936 - mdi->st_db_readonly = rrdset_create_localhost(
2937 - "mssql",
2938 - id,
2939 - NULL,
2940 - "locks",
2941 - "mssql.database_readonly",
2942 - "Current database write status.",
2943 - "status",
2944 - PLUGIN_WINDOWS_NAME,
2945 - "PerflibMSSQL",
2946 - PRIO_MSSQL_DATABASE_READONLY,
2947 - update_every,
2948 - RRDSET_TYPE_LINE);
2949 -
2950 - rrdlabels_add(mdi->st_db_readonly->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2951 - rrdlabels_add(mdi->st_db_readonly->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2952 -
2953 - mdi->rd_db_readonly_yes = rrddim_add(mdi->st_db_readonly, "writable", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2954 - mdi->rd_db_readonly_no = rrddim_add(mdi->st_db_readonly, "readonly", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2955 - }
2956 -
2957 - rrddim_set_by_pointer(
2958 - mdi->st_db_readonly, mdi->rd_db_readonly_no, (collected_number)mdi->MSSQLDBIsReadonly.current.Data);
2959 -
2960 - collected_number opposite = (mdi->MSSQLDBIsReadonly.current.Data) ? 0 : 1;
2961 - rrddim_set_by_pointer(mdi->st_db_readonly, mdi->rd_db_readonly_yes, (collected_number)opposite);
2962 -
2963 - rrdset_done(mdi->st_db_readonly);
2964 -}
2965 -
2966 -static void mssql_db_states_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
2967 -{
2968 - if (unlikely(!mdi->st_db_state)) {
2969 - char id[RRD_ID_LENGTH_MAX + 1];
2970 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_state", db, mdi->parent->instanceID);
2971 - netdata_fix_chart_name(id);
2972 - mdi->st_db_state = rrdset_create_localhost(
2973 - "mssql",
2974 - id,
2975 - NULL,
2976 - "locks",
2977 - "mssql.database_state",
2978 - "Current database state.",
2979 - "status",
2980 - PLUGIN_WINDOWS_NAME,
2981 - "PerflibMSSQL",
2982 - PRIO_MSSQL_DATABASE_STATE,
2983 - update_every,
2984 - RRDSET_TYPE_LINE);
2985 -
2986 - rrdlabels_add(mdi->st_db_state->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
2987 - rrdlabels_add(mdi->st_db_state->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
2988 -
2989 - mdi->rd_db_state[0] = rrddim_add(mdi->st_db_state, "online", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2990 - mdi->rd_db_state[1] = rrddim_add(mdi->st_db_state, "restoring", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2991 - mdi->rd_db_state[2] = rrddim_add(mdi->st_db_state, "recovering", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2992 - mdi->rd_db_state[3] = rrddim_add(mdi->st_db_state, "recovering_pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2993 - mdi->rd_db_state[4] = rrddim_add(mdi->st_db_state, "suspect", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2994 - mdi->rd_db_state[5] = rrddim_add(mdi->st_db_state, "offline", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2995 - }
2996 -}
2997 -
2998 -static void mssql_db_state_chart_loop(struct mssql_db_instance *mdi, const char *db, int update_every)
2999 -{
3000 - collected_number set_value =
3001 - (mdi->MSSQLDBState.current.Data < 5) ? (collected_number)mdi->MSSQLDBState.current.Data : 5;
3002 - mssql_db_states_chart(mdi, db, update_every);
3003 - for (collected_number i = 0; i < NETDATA_DB_STATES; i++) {
3004 - rrddim_set_by_pointer(mdi->st_db_state, mdi->rd_db_state[i], i == set_value);
3005 - }
3006 - rrdset_done(mdi->st_db_state);
3007 -}
3008 -
3009 -static void mssql_lock_request_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
3010 -{
3011 - if (unlikely(!mdi->st_lock_requests)) {
3012 - char id[RRD_ID_LENGTH_MAX + 1];
3013 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_lock_requests", db, mdi->parent->instanceID);
3014 - netdata_fix_chart_name(id);
3015 - mdi->st_lock_requests = rrdset_create_localhost(
3016 - "mssql",
3017 - id,
3018 - NULL,
3019 - "locks",
3020 - "mssql.database_lock_requests",
3021 - "Number of new locks and lock conversions requested.",
3022 - "requests/s",
3023 - PLUGIN_WINDOWS_NAME,
3024 - "PerflibMSSQL",
3025 - PRIO_MSSQL_DATABASE_LOCK_REQUESTS_SEC,
3026 - update_every,
3027 - RRDSET_TYPE_LINE);
3028 -
3029 - rrdlabels_add(mdi->st_lock_requests->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
3030 - rrdlabels_add(mdi->st_lock_requests->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
3031 -
3032 - mdi->rd_lock_requests = rrddim_add(mdi->st_lock_requests, "requests", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3033 - }
3034 -
3035 - rrddim_set_by_pointer(
3036 - mdi->st_lock_requests, mdi->rd_lock_requests, (collected_number)mdi->MSSQLDatabaseLockRequestsSec.current.Data);
3037 -
3038 - rrdset_done(mdi->st_lock_requests);
3039 -}
3040 -
3041 -static void mssql_lock_timeout_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
3042 -{
3043 - if (unlikely(!mdi->st_lock_timeouts)) {
3044 - char id[RRD_ID_LENGTH_MAX + 1];
3045 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_lock_timeouts", db, mdi->parent->instanceID);
3046 - netdata_fix_chart_name(id);
3047 - mdi->st_lock_timeouts = rrdset_create_localhost(
3048 - "mssql",
3049 - id,
3050 - NULL,
3051 - "locks",
3052 - "mssql.database_lock_timeouts",
3053 - "Lock that timed out.",
3054 - "timeouts/s",
3055 - PLUGIN_WINDOWS_NAME,
3056 - "PerflibMSSQL",
3057 - PRIO_MSSQL_DATABASE_LOCKS_TIMEOUT_PER_SECOND,
3058 - update_every,
3059 - RRDSET_TYPE_LINE);
3060 -
3061 - rrdlabels_add(mdi->st_lock_timeouts->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
3062 - rrdlabels_add(mdi->st_lock_timeouts->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
3063 -
3064 - mdi->rd_lock_timeouts = rrddim_add(mdi->st_lock_timeouts, "timeouts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3065 - }
3066 -
3067 - rrddim_set_by_pointer(
3068 - mdi->st_lock_timeouts, mdi->rd_lock_timeouts, (collected_number)mdi->MSSQLDatabaseLockTimeoutsSec.current.Data);
3069 -
3070 - rrdset_done(mdi->st_lock_timeouts);
3071 -}
3072 -
3073 -static void mssql_active_transactions_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
3074 -{
3075 - if (unlikely(!mdi->st_db_active_transactions)) {
3076 - char id[RRD_ID_LENGTH_MAX + 1];
3077 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_active_transactions", db, mdi->parent->instanceID);
3078 - netdata_fix_chart_name(id);
3079 - mdi->st_db_active_transactions = rrdset_create_localhost(
3080 - "mssql",
3081 - id,
3082 - NULL,
3083 - "transactions",
3084 - "mssql.database_active_transactions",
3085 - "Active transactions per database",
3086 - "transactions",
3087 - PLUGIN_WINDOWS_NAME,
3088 - "PerflibMSSQL",
3089 - PRIO_MSSQL_DATABASE_ACTIVE_TRANSACTIONS,
3090 - update_every,
3091 - RRDSET_TYPE_LINE);
3092 -
3093 - rrdlabels_add(
3094 - mdi->st_db_active_transactions->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
3095 - rrdlabels_add(mdi->st_db_active_transactions->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
3096 -
3097 - mdi->rd_db_active_transactions =
3098 - rrddim_add(mdi->st_db_active_transactions, "active", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3099 - }
3100 -
3101 - rrddim_set_by_pointer(
3102 - mdi->st_db_active_transactions,
3103 - mdi->rd_db_active_transactions,
3104 - (collected_number)mdi->MSSQLDatabaseActiveTransactions.current.Data);
3105 -
3106 - rrdset_done(mdi->st_db_active_transactions);
3107 -}
3108 -
3109 -static inline void mssql_data_file_size_chart(struct mssql_db_instance *mdi, const char *db, int update_every)
3110 -{
3111 - if (unlikely(!mdi->st_db_data_file_size)) {
3112 - char id[RRD_ID_LENGTH_MAX + 1];
3113 - snprintfz(id, RRD_ID_LENGTH_MAX, "db_%s_instance_%s_data_files_size", db, mdi->parent->instanceID);
3114 - netdata_fix_chart_name(id);
3115 - mdi->st_db_data_file_size = rrdset_create_localhost(
3116 - "mssql",
3117 - id,
3118 - NULL,
3119 - "size",
3120 - "mssql.database_data_files_size",
3121 - "Current database size.",
3122 - "bytes",
3123 - PLUGIN_WINDOWS_NAME,
3124 - "PerflibMSSQL",
3125 - PRIO_MSSQL_DATABASE_DATA_FILE_SIZE,
3126 - update_every,
3127 - RRDSET_TYPE_LINE);
3128 -
3129 - rrdlabels_add(
3130 - mdi->st_db_data_file_size->rrdlabels, "mssql_instance", mdi->parent->instanceID, RRDLABEL_SRC_AUTO);
3131 - rrdlabels_add(mdi->st_db_data_file_size->rrdlabels, "database", db, RRDLABEL_SRC_AUTO);
3132 -
3133 - mdi->rd_db_data_file_size = rrddim_add(mdi->st_db_data_file_size, "size", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3134 - }
3135 -
3136 - collected_number data = mdi->MSSQLDatabaseDataFileSize.current.Data;
3137 - rrddim_set_by_pointer(mdi->st_db_data_file_size, mdi->rd_db_data_file_size, data);
3138 -
3139 - rrdset_done(mdi->st_db_data_file_size);
3140 -}
3141 -
3142 -int dict_mssql_databases_charts_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
3143 -{
3144 - struct mssql_db_instance *mdi = value;
3145 - const char *db = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
3146 -
3147 - if (unlikely(!mdi->collecting_data)) {
3148 - goto endchartcb;
3149 - }
3150 -
3151 - int *update_every = data;
3152 - struct mssql_instance *mi = mdi->parent;
3153 - if (unlikely(!mi))
3154 - goto endchartcb;
3155 -
3156 - struct netdata_mssql_conn *conn = mi->conn;
3157 - if (unlikely(!conn))
3158 - goto endchartcb;
3159 -
3160 - if (likely(conn->collect_data_size))
3161 - mssql_data_file_size_chart(mdi, db, *update_every);
3162 -
3163 - if (likely(conn->collect_transactions)) {
3164 - mssql_transactions_chart(mdi, db, *update_every);
3165 - mssql_active_transactions_chart(mdi, db, *update_every);
3166 - mssql_write_transactions_chart(mdi, db, *update_every);
3167 - }
3168 -
3169 - if (likely(conn->collect_waits)) {
3170 - mssql_lockwait_chart(mdi, db, *update_every);
3171 - }
3172 -
3173 - if (likely(conn->collect_locks)) {
3174 - mssql_deadlock_chart(mdi, db, *update_every);
3175 - mssql_lock_timeout_chart(mdi, db, *update_every);
3176 - mssql_lock_request_chart(mdi, db, *update_every);
3177 - }
3178 -
3179 - mssql_is_readonly_chart(mdi, db, *update_every);
3180 - mssql_db_state_chart_loop(mdi, db, *update_every);
3181 - mssql_database_log_flushed_chart(mdi, db, *update_every);
3182 - mssql_database_log_flushes_chart(mdi, db, *update_every);
3183 - mssql_database_backup_restore_chart(mdi, db, *update_every);
3184 -
3185 -endchartcb:
3186 - return 1;
3187 -}
3188 -
3189 -static void do_mssql_databases(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
3190 -{
3191 - if (unlikely(!pDataBlock))
3192 - goto end_mssql_databases;
3193 -
3194 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_DATABASE]);
3195 - if (unlikely(!pObjectType))
3196 - return;
3197 -
3198 - PERF_INSTANCE_DEFINITION *pi = NULL;
3199 - for (LONG i = 0; i < pObjectType->NumInstances; i++) {
3200 - pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
3201 - if (unlikely(!pi))
3202 - break;
3203 -
3204 - if (unlikely(
3205 - !getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer))))
3206 - strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
3207 -
3208 - if (unlikely(!strcasecmp(windows_shared_buffer, "_Total")))
3209 - continue;
3210 -
3211 - struct mssql_db_instance *mdi = dictionary_set(mi->databases, windows_shared_buffer, NULL, sizeof(*mdi));
3212 - if (unlikely(!mdi))
3213 - continue;
3214 -
3215 - if (unlikely(!mdi->parent)) {
3216 - mdi->parent = mi;
3217 - }
3218 -
3219 - if (unlikely(!i))
3220 - mdi->collect_instance = true;
3221 - }
3222 -
3223 -end_mssql_databases:
3224 - dictionary_sorted_walkthrough_read(mi->databases, dict_mssql_databases_charts_cb, &update_every);
3225 -}
3226 -
3227 -int dict_mssql_charts_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
3228 -{
3229 - struct mssql_instance *mi = value;
3230 - int *update_every = data;
3231 -
3232 - static void (*doMSSQL[])(PERF_DATA_BLOCK *, struct mssql_instance *, int) = {
3233 - do_mssql_general_stats,
3234 - do_mssql_errors,
3235 - do_mssql_memory_mgr,
3236 - do_mssql_statistics_perflib,
3237 - do_mssql_access_methods,
3238 -
3239 - do_mssql_databases,
3240 - do_mssql_locks,
3241 - do_mssql_waits,
3242 - do_mssql_bufferman_stats_sql,
3243 - do_mssql_job_status_sql,
3244 - do_mssql_user_connection,
3245 - do_mssql_blocked_processes,
3246 -
3247 - NULL};
3248 -
3249 - DWORD i;
3250 - PERF_DATA_BLOCK *pDataBlock;
3251 - static bool collect_perflib[NETDATA_MSSQL_METRICS_END] = {
3252 - true, true, true, true, true, true, true, true, true, true, false, false};
3253 - for (i = 0; i < NETDATA_MSSQL_ACCESS_METHODS; i++) {
3254 - if (unlikely(!collect_perflib[i]))
3255 - continue;
3256 -
3257 - pDataBlock = netdata_mssql_get_perf_data_block(collect_perflib, mi, i);
3258 - if (unlikely(!pDataBlock))
3259 - continue;
3260 -
3261 - doMSSQL[i](pDataBlock, mi, *update_every);
3262 - }
3263 -
3264 - if (unlikely(unlikely(!mi->conn || !mi->conn->is_connected)))
3265 - return 1;
3266 -
3267 - for (i = NETDATA_MSSQL_DATABASE; doMSSQL[i]; i++) {
3268 - pDataBlock = (collect_perflib[i]) ? netdata_mssql_get_perf_data_block(collect_perflib, mi, i) : NULL;
3269 -
3270 - doMSSQL[i](pDataBlock, mi, *update_every);
3271 - }
3272 -
3273 - do_mssql_replication(mi, *update_every);
3274 -
3275 - return 1;
3276 -}
3277 -
3278 -// Entry point
3279 -
3280 -int do_PerflibMSSQL(int update_every, usec_t dt __maybe_unused)
3281 -{
3282 - static bool initialized = false;
3283 -
3284 - if (unlikely(!initialized)) {
3285 - if (initialize(update_every))
3286 - return -1;
3287 -
3288 - initialized = true;
3289 - }
3290 -
3291 - dictionary_sorted_walkthrough_read(mssql_instances, dict_mssql_charts_cb, &update_every);
3292 -
3293 - return 0;
3294 -}
3295 -
3296 -void do_PerflibMSSQL_cleanup()
3297 -{
3298 - if (likely(nd_thread_join(mssql_queries_thread)))
3299 - nd_log_daemon(NDLP_ERR, "Failed to join mssql queries thread");
3300 -}
src/collectors/windows.plugin/README.md
+2 -171
@@ -26,7 +26,6 @@ To change a setting, remove the comment symbol (`#`) from the beginning of the l
26 # PerflibThermalZone = no
27 # PerflibWebService = yes
28 # PerflibServices = no
29 - # PerflibMSSQL = yes
29 # PerflibNetFramework = yes
30 # PerflibAD = yes
31 # PerflibADCS = yes
@@ -37,13 +36,13 @@ To change a setting, remove the comment symbol (`#`) from the beginning of the l
36
37 ## Update Every per Thread
38
40 -When the plugin is running, most threads will collect data using Netdata’s default update `every interval`. However,
39 +When the plugin is running, most threads will collect data using Netdata's default update `every interval`. However,
40 to avoid overloading the host, Netdata uses different `update every` intervals for specific threads, as shown below:
41
42 | Period (seconds) | Threads |
43 |------------------|----------------------------------------------------------------------------------|
44 | 5 | `PerflibHyperV`, `PerflibThermalZone` |
46 -| 10 | `PerflibMSSQL`, `PerflibAD`, `PerflibADCS`, `PerflibADFS`, and `PerflibExchange` |
45 +| 10 | `PerflibAD`, `PerflibADCS`, `PerflibADFS`, and `PerflibExchange` |
46 | 30 | `PerflibServices` |
47
48 To customize the update interval for a specific thread, you can set the update every value within the corresponding
@@ -57,171 +56,3 @@ and `HyperV` threads:
56 [plugin:windows:PerflibHyperV]
57 #update every = 15s
58 ```
60 -
61 -## Microsoft SQL Server Integration
62 -
63 -To collect metrics from [Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server), Netdata needs access to internal server data. This requires configuration on both the Windows system and Netdata sides.
64 -
65 -## Configuring
66 -
67 -### Step 1: Configure Windows Defender Firewall
68 -
69 -Netdata connects to SQL Server using TCP port 1433 (or your custom-configured port). You'll need to create a firewall rule to allow this connection:
70 -
71 -1. Open `Windows Defender Firewall with Advanced Security` as an Administrator
72 -2. Right-click `Inbound Rules` and select `New Rule...`
73 -3. Select `Port`, then click `Next`
74 -4. Choose `TCP`, enter `1433` in the `Specific local ports:` field, then click `Next`
75 -5. Select an appropriate action (typically `Allow the connection`), then click `Next`
76 -6. Choose where the rule applies (Domain, Private, or Public networks), then click `Next`
77 -7. Provide a name and optional description for the rule, then click `Finish`
78 -
79 -For multiple SQL Server instances, you can specify multiple ports in the same rule by separating them with commas.
80 -
81 -### Step 2: Configure SQL Server Network Settings
82 -
83 -Enable SQL Server to accept TCP connections:
84 -
85 -1. Open `SQL Server Configuration Manager`
86 -2. Expand `SQL Server Network Configuration`
87 -3. Select `Protocols for <instance name>` in the console panel
88 -4. Double-click the `TCP` protocol in the details panel and set `Enabled` to `Yes`
89 -5. Go to the `IP Address` tab and locate the `IPAII` section:
90 - - Clear any value from the `TCP Dynamic Ports` field
91 - - Enter a port number in the `TCP Port` field (default is `1433`)
92 -6. Select `SQL Server Services` and restart your SQL Server instance
93 -
94 -These steps must be performed for each SQL Server instance you want to monitor.
95 -
96 -### Step 3: Configure SQL Server Authentication
97 -
98 -If you're using SQL Server authentication (rather than Windows authentication):
99 -
100 -1. Open `SQL Server Management Studio`
101 -2. Right-click your server and select `Properties`
102 -3. Select `Security` in the left panel
103 -4. Choose `SQL Server and Windows Authentication mode` under `Server authentication`
104 -5. Click `OK`
105 -6. Right-click your server and select `Restart`
106 -
107 -### Step 4: Create a Monitoring User
108 -
109 -Create an SQL Server user with the necessary permissions to collect monitoring data:
110 -
111 -```tsql
112 -USE master;
113 -CREATE LOGIN netdata_user WITH PASSWORD = '1ReallyStrongPasswordShouldBeInsertedHere';
114 -CREATE USER netdata_user FOR LOGIN netdata_user;
115 -GRANT CONNECT SQL TO netdata_user;
116 -GRANT VIEW SERVER STATE TO netdata_user;
117 -GO
118 -```
119 -
120 -Additionally, enable the [Query Store](https://learn.microsoft.com/en-us/sql/relational-databases/performance/monitoring-performance-by-using-the-query-store?view=sql-server-ver16) on each database you want to monitor:
121 -
122 -```tsql
123 -DECLARE @dbname NVARCHAR(max)
124 -DECLARE nd_user_cursor CURSOR FOR SELECT name
125 - FROM master.dbo.sysdatabases
126 - WHERE name NOT IN ('master')
127 -
128 -OPEN nd_user_cursor
129 -FETCH NEXT FROM nd_user_cursor INTO @dbname
130 -WHILE @@FETCH_STATUS = 0
131 - BEGIN
132 - EXECUTE ("USE "+ @dbname+"; CREATE USER netdata_user FOR LOGIN netdata_user; ALTER DATABASE "+@dbname+" SET QUERY_STORE = ON ( QUERY_CAPTURE_MODE = ALL, DATA_FLUSH_INTERVAL_SECONDS = 900 )");
133 - FETCH next FROM nd_user_cursor INTO @dbname;
134 - END
135 -CLOSE nd_user_cursor
136 -DEALLOCATE nd_user_cursor
137 -GO
138 -```
139 -
140 -Apply this configuration to each SQL Server instance you wish to monitor.
141 -
142 -### Step 5: Configure Netdata
143 -
144 -Add the SQL Server connection details to your `netdata.conf` file:
145 -
146 -```
147 -[plugin:windows:PerflibMSSQL]
148 - driver = SQL Server
149 - server = 127.0.0.1\\Dev, 1433
150 - instance = Dev
151 - #address = [protocol:]Address[,port |\pipe\pipename]
152 - uid = netdata_user
153 - pwd = 1ReallyStrongPasswordShouldBeInsertedHere
154 - express = no
155 - # additional instances = 0
156 - #windows authentication = no
157 -```
158 -
159 -Configuration options:
160 -
161 -| Option | Description |
162 -|--------------------------|------------------------------------------------------------------------------|
163 -| `driver` | ODBC driver used to connect to the SQL Server |
164 -| `server` | Server address or instance name |
165 -| `instance` | Instance name |
166 -| `address` | Alternative to `server`; supports named pipes if the server supports them |
167 -| `uid` | SQL Server user identifier |
168 -| `pwd` | Password for the specified user |
169 -| `additional instances` | Number of additional SQL Server instances to monitor |
170 -| `windows authentication` | Set to `yes` to use Windows credentials instead of SQL Server authentication |
171 -| `express` | Set to `yes` when running SQL Express version |
172 -
173 -The `instance` option is required when Netdata pulls data from outside an MSSQL server.
174 -
175 -For more information on connection parameters, see the [Microsoft Official Documentation](https://learn.microsoft.com/en-us/sql/relational-databases/native-client/applications/using-connection-string-keywords-with-sql-server-native-client?view=sql-server-ver15&viewFallbackFrom=sql-server-ver16).
176 -
177 -## Monitoring Multiple SQL Server Instances
178 -
179 -SQL Server can host multiple instances on the same machine. To monitor additional instances:
180 -
181 -1. Update the main section to specify the number of additional instances:
182 - ```text
183 - [plugin:windows:PerflibMSSQL]
184 - additional instances = 1
185 - ```
186 -2. Add a new configuration section for each additional instance, using sequential numbering:
187 - ```text
188 - [plugin:windows:PerflibMSSQL1]
189 - driver = SQL Server
190 - server = 127.0.0.1\\Production, 1434
191 - uid = netdata_user
192 - pwd = AnotherReallyStrongPasswordShouldBeInsertedHere2$
193 - ```
194 -
195 -Each additional instance section must follow the naming pattern `plugin:windows:PerflibMSSQL` with a sequential number from 1 to 65535.
196 -
197 -## Troubleshooting Common Issues
198 -
199 -### Data source name is not found and no default driver
200 -
201 -This error occurs when the specified ODBC driver is incorrect. To check available drivers:
202 -
203 -1. Open `ODBC Data Sources`
204 -2. Go to the `Drivers` tab
205 -3. Look for the correct name of the `ODBC` or SQL `Server driver`
206 -
207 -### Database Metrics Not Visible
208 -
209 -If a database isn't appearing on the Netdata dashboard, statistics collection might not be enabled:
210 -
211 -1. Open `SQL Server Configuration Manager`
212 -2. Right-click the database and select `Properties`
213 -3. Select `Options` in the left pane
214 -4. Set `Auto Create Statistics` to `True`
215 -
216 -### Login Failed
217 -
218 -If authentication fails, check the SQL Server error log at:
219 -
220 -```
221 -C:\Program Files\Microsoft SQL Server\VERSION\MSSQL\Log\ERRORLOG
222 -```
223 -
224 -Where `VERSION` corresponds to your SQL Server version.
225 -
226 -You can also check Windows Event Viewer for entries beginning with `MSSQL server error using the handle`.
227 -
src/collectors/windows.plugin/perflib-mssql-queries.h deleted
-1006
@@ -1,1006 +0,0 @@
1 -// SPDX-License-Identifier: GPL-3.0-or-later
2 -
3 -#ifndef NETDATA_PERFLIB_MSSQL_QUERIES_H
4 -#define NETDATA_PERFLIB_MSSQL_QUERIES_H
5 -
6 -#include <sqlext.h>
7 -#include <sqltypes.h>
8 -#include <sql.h>
9 -
10 -// https://learn.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-tran-locks-transact-sql?view=sql-server-ver16
11 -#define NETDATA_QUERY_LOCKS_MASK \
12 - "SELECT resource_type, count(*) FROM %s.sys.dm_tran_locks WHERE DB_NAME(resource_database_id) = '%s' group by resource_type;"
13 -
14 -#define NETDATA_REPLICATION_DB "distribution"
15 -
16 -#define NETDATA_REPLICATION_MONITOR_QUERY "EXEC sp_replmonitorhelppublication;"
17 -
18 -#define NETDATA_QUERY_LIST_DB "SELECT name FROM sys.databases;"
19 -
20 -// https://learn.microsoft.com/en-us/sql/relational-databases/system-catalog-views/sys-database-files-transact-sql?view=sql-server-ver16
21 -#define NETDATA_QUERY_DATA_FILE_SIZE_MASK "SELECT size * 8/1024 FROM %s.sys.database_files WHERE type = 0;"
22 -
23 -// https://learn.microsoft.com/en-us/sql/relational-databases/system-compatibility-views/sys-sysprocesses-transact-sql?view=sql-server-ver16
24 -// SQL SERVER BEFORE 2008 DOES NOT HAVE DATA IN THIS TABLE
25 -// https://github.com/influxdata/telegraf/blob/081dfa26e80d8764fb7f9aac5230e81584b62b56/plugins/inputs/sqlserver/sqlqueriesV2.go#L1259
26 -#define NETDATA_QUERY_PERFORMANCE_COUNTER \
27 - "SELECT counter_name, cntr_value FROM %s.sys.dm_os_performance_counters WHERE ltrim(rtrim(instance_name)) = '%s' AND counter_name IN ('Active Transactions', 'Transactions/sec', 'Write Transactions/sec', 'Backup/Restore Throughput/sec', 'Log Bytes Flushed/sec', 'Log Flushes/sec', 'Number of Deadlocks/sec', 'Lock Waits/sec', 'Lock Timeouts/sec', 'Lock Requests/sec', 'Page reads/sec', 'Page writes/sec', 'Buffer cache hit ratio', 'Checkpoint pages/sec', 'Page life expectancy', 'Lazy writes/sec', 'Page Lookups/sec', 'SQL Compilations/sec', 'SQL Re-Compilations/sec');"
28 -
29 -#define NETDATA_QUERY_CHECK_PERM \
30 - "SELECT CASE WHEN IS_SRVROLEMEMBER('sysadmin') = 1 OR HAS_PERMS_BY_NAME(null, null, 'VIEW SERVER STATE') = 1 THEN 1 ELSE 0 END AS has_permission;"
31 -
32 -#define NETDATA_DB_STATES (6)
33 -#define NETDATA_QUERY_DATABASE_STATUS "SELECT name, state, is_read_only FROM sys.databases;"
34 -
35 -#define NETDATA_QUERY_JOBS_STATUS "SELECT name, enabled FROM msdb.dbo.sysjobs;"
36 -
37 -#define NETDATA_QUERY_CONNECTIONS "SELECT COUNT(*), is_user_process FROM sys.dm_exec_sessions GROUP BY is_user_process;"
38 -
39 -#define NETDATA_QUERY_BLOCKED_PROCESSES \
40 - "SELECT COUNT(DISTINCT session_id) AS blocked_sessions FROM sys.dm_exec_requests WHERE blocking_session_id <> 0;"
41 -
42 -// https://learn.microsoft.com/en-us/sql/relational-databases/system-dynamic-management-views/sys-dm-os-wait-stats-transact-sql?view=sql-server-ver16
43 -#define NETDATA_QUERY_CHECK_WAITS \
44 - "SELECT \
45 - ws.[wait_type], ws.[wait_time_ms], ws.[wait_time_ms] - ws.[signal_wait_time_ms] AS[resource_wait_ms], \
46 - ws.[signal_wait_time_ms], ws.[max_wait_time_ms], ws.[waiting_tasks_count], \
47 - ISNULL(wc.[wait_category], 'OTHER') AS[wait_category] FROM sys.dm_os_wait_stats AS ws WITH(NOLOCK) \
48 - LEFT OUTER JOIN( \
49 - VALUES('ASYNC_IO_COMPLETION', 'Other Disk IO'), \
50 - ('ASYNC_NETWORK_IO', 'Network IO'), \
51 - ('BACKUPIO', 'Other Disk IO'), \
52 - ('BROKER_CONNECTION_RECEIVE_TASK', 'Service Broker'), \
53 - ('BROKER_DISPATCHER', 'Service Broker'), \
54 - ('BROKER_ENDPOINT_STATE_MUTEX', 'Service Broker'), \
55 - ('BROKER_EVENTHANDLER', 'Service Broker'), \
56 - ('BROKER_FORWARDER', 'Service Broker'), \
57 - ('BROKER_INIT', 'Service Broker'), \
58 - ('BROKER_MASTERSTART', 'Service Broker'), \
59 - ('BROKER_RECEIVE_WAITFOR', 'User Wait'), \
60 - ('BROKER_REGISTERALLENDPOINTS', 'Service Broker'), \
61 - ('BROKER_SERVICE', 'Service Broker'), \
62 - ('BROKER_SHUTDOWN', 'Service Broker'), \
63 - ('BROKER_START', 'Service Broker'), \
64 - ('BROKER_TASK_SHUTDOWN', 'Service Broker'), \
65 - ('BROKER_TASK_STOP', 'Service Broker'), \
66 - ('BROKER_TASK_SUBMIT', 'Service Broker'), \
67 - ('BROKER_TO_FLUSH', 'Service Broker'), \
68 - ('BROKER_TRANSMISSION_OBJECT', 'Service Broker'), \
69 - ('BROKER_TRANSMISSION_TABLE', 'Service Broker'), \
70 - ('BROKER_TRANSMISSION_WORK', 'Service Broker'), \
71 - ('BROKER_TRANSMITTER', 'Service Broker'), \
72 - ('CHECKPOINT_QUEUE', 'Idle'), \
73 - ('CHKPT', 'Tran Log IO'), \
74 - ('CLR_AUTO_EVENT', 'SQL CLR'), \
75 - ('CLR_CRST', 'SQL CLR'), \
76 - ('CLR_JOIN', 'SQL CLR'), \
77 - ('CLR_MANUAL_EVENT', 'SQL CLR'), \
78 - ('CLR_MEMORY_SPY', 'SQL CLR'), \
79 - ('CLR_MONITOR', 'SQL CLR'), \
80 - ('CLR_RWLOCK_READER', 'SQL CLR'), \
81 - ('CLR_RWLOCK_WRITER', 'SQL CLR'), \
82 - ('CLR_SEMAPHORE', 'SQL CLR'), \
83 - ('CLR_TASK_START', 'SQL CLR'), \
84 - ('CLRHOST_STATE_ACCESS', 'SQL CLR'), \
85 - ('CMEMPARTITIONED', 'Memory'), \
86 - ('CMEMTHREAD', 'Memory'), \
87 - ('CXPACKET', 'Parallelism'), \
88 - ('CXCONSUMER', 'Parallelism'), \
89 - ('DBMIRROR_DBM_EVENT', 'Mirroring'), \
90 - ('DBMIRROR_DBM_MUTEX', 'Mirroring'), \
91 - ('DBMIRROR_EVENTS_QUEUE', 'Mirroring'), \
92 - ('DBMIRROR_SEND', 'Mirroring'), \
93 - ('DBMIRROR_WORKER_QUEUE', 'Mirroring'), \
94 - ('DBMIRRORING_CMD', 'Mirroring'), \
95 - ('DTC', 'Transaction'), \
96 - ('DTC_ABORT_REQUEST', 'Transaction'), \
97 - ('DTC_RESOLVE', 'Transaction'), \
98 - ('DTC_STATE', 'Transaction'), \
99 - ('DTC_TMDOWN_REQUEST', 'Transaction'), \
100 - ('DTC_WAITFOR_OUTCOME', 'Transaction'), \
101 - ('DTCNEW_ENLIST', 'Transaction'), \
102 - ('DTCNEW_PREPARE', 'Transaction'), \
103 - ('DTCNEW_RECOVERY', 'Transaction'), \
104 - ('DTCNEW_TM', 'Transaction'), \
105 - ('DTCNEW_TRANSACTION_ENLISTMENT', 'Transaction'), \
106 - ('DTCPNTSYNC', 'Transaction'), \
107 - ('EE_PMOLOCK', 'Memory'), \
108 - ('EXCHANGE', 'Parallelism'), \
109 - ('EXTERNAL_SCRIPT_NETWORK_IOF', 'Network IO'), \
110 - ('FCB_REPLICA_READ', 'Replication'), \
111 - ('FCB_REPLICA_WRITE', 'Replication'), \
112 - ('FT_COMPROWSET_RWLOCK', 'Full Text Search'), \
113 - ('FT_IFTS_RWLOCK', 'Full Text Search'), \
114 - ('FT_IFTS_SCHEDULER_IDLE_WAIT', 'Idle'), \
115 - ('FT_IFTSHC_MUTEX', 'Full Text Search'), \
116 - ('FT_IFTSISM_MUTEX', 'Full Text Search'), \
117 - ('FT_MASTER_MERGE', 'Full Text Search'), \
118 - ('FT_MASTER_MERGE_COORDINATOR', 'Full Text Search'), \
119 - ('FT_METADATA_MUTEX', 'Full Text Search'), \
120 - ('FT_PROPERTYLIST_CACHE', 'Full Text Search'), \
121 - ('FT_RESTART_CRAWL', 'Full Text Search'), \
122 - ('FULLTEXT GATHERER', 'Full Text Search'), \
123 - ('HADR_AG_MUTEX', 'Replication'), \
124 - ('HADR_AR_CRITICAL_SECTION_ENTRY', 'Replication'), \
125 - ('HADR_AR_MANAGER_MUTEX', 'Replication'), \
126 - ('HADR_AR_UNLOAD_COMPLETED', 'Replication'), \
127 - ('HADR_ARCONTROLLER_NOTIFICATIONS_SUBSCRIBER_LIST', 'Replication'), \
128 - ('HADR_BACKUP_BULK_LOCK', 'Replication'), \
129 - ('HADR_BACKUP_QUEUE', 'Replication'), \
130 - ('HADR_CLUSAPI_CALL', 'Replication'), \
131 - ('HADR_COMPRESSED_CACHE_SYNC', 'Replication'), \
132 - ('HADR_CONNECTIVITY_INFO', 'Replication'), \
133 - ('HADR_DATABASE_FLOW_CONTROL', 'Replication'), \
134 - ('HADR_DATABASE_VERSIONING_STATE', 'Replication'), \
135 - ('HADR_DATABASE_WAIT_FOR_RECOVERY', 'Replication'), \
136 - ('HADR_DATABASE_WAIT_FOR_RESTART', 'Replication'), \
137 - ('HADR_DATABASE_WAIT_FOR_TRANSITION_TO_VERSIONING', 'Replication'), \
138 - ('HADR_DB_COMMAND', 'Replication'), \
139 - ('HADR_DB_OP_COMPLETION_SYNC', 'Replication'), \
140 - ('HADR_DB_OP_START_SYNC', 'Replication'), \
141 - ('HADR_DBR_SUBSCRIBER', 'Replication'), \
142 - ('HADR_DBR_SUBSCRIBER_FILTER_LIST', 'Replication'), \
143 - ('HADR_DBSEEDING', 'Replication'), \
144 - ('HADR_DBSEEDING_LIST', 'Replication'), \
145 - ('HADR_DBSTATECHANGE_SYNC', 'Replication'), \
146 - ('HADR_FABRIC_CALLBACK', 'Replication'), \
147 - ('HADR_FILESTREAM_BLOCK_FLUSH', 'Replication'), \
148 - ('HADR_FILESTREAM_FILE_CLOSE', 'Replication'), \
149 - ('HADR_FILESTREAM_FILE_REQUEST', 'Replication'), \
150 - ('HADR_FILESTREAM_IOMGR', 'Replication'), \
151 - ('HADR_FILESTREAM_IOMGR_IOCOMPLETION', 'Replication'), \
152 - ('HADR_FILESTREAM_MANAGER', 'Replication'), \
153 - ('HADR_FILESTREAM_PREPROC', 'Replication'), \
154 - ('HADR_GROUP_COMMIT', 'Replication'), \
155 - ('HADR_LOGCAPTURE_SYNC', 'Replication'), \
156 - ('HADR_LOGCAPTURE_WAIT', 'Replication'), \
157 - ('HADR_LOGPROGRESS_SYNC', 'Replication'), \
158 - ('HADR_NOTIFICATION_DEQUEUE', 'Replication'), \
159 - ('HADR_NOTIFICATION_WORKER_EXCLUSIVE_ACCESS', 'Replication'), \
160 - ('HADR_NOTIFICATION_WORKER_STARTUP_SYNC', 'Replication'), \
161 - ('HADR_NOTIFICATION_WORKER_TERMINATION_SYNC', 'Replication'), \
162 - ('HADR_PARTNER_SYNC', 'Replication'), \
163 - ('HADR_READ_ALL_NETWORKS', 'Replication'), \
164 - ('HADR_RECOVERY_WAIT_FOR_CONNECTION', 'Replication'), \
165 - ('HADR_RECOVERY_WAIT_FOR_UNDO', 'Replication'), \
166 - ('HADR_REPLICAINFO_SYNC', 'Replication'), \
167 - ('HADR_SEEDING_CANCELLATION', 'Replication'), \
168 - ('HADR_SEEDING_FILE_LIST', 'Replication'), \
169 - ('HADR_SEEDING_LIMIT_BACKUPS', 'Replication'), \
170 - ('HADR_SEEDING_SYNC_COMPLETION', 'Replication'), \
171 - ('HADR_SEEDING_TIMEOUT_TASK', 'Replication'), \
172 - ('HADR_SEEDING_WAIT_FOR_COMPLETION', 'Replication'), \
173 - ('HADR_SYNC_COMMIT', 'Replication'), \
174 - ('HADR_SYNCHRONIZING_THROTTLE', 'Replication'), \
175 - ('HADR_TDS_LISTENER_SYNC', 'Replication'), \
176 - ('HADR_TDS_LISTENER_SYNC_PROCESSING', 'Replication'), \
177 - ('HADR_THROTTLE_LOG_RATE_GOVERNOR', 'Log Rate Governor'), \
178 - ('HADR_TIMER_TASK', 'Replication'), \
179 - ('HADR_TRANSPORT_DBRLIST', 'Replication'), \
180 - ('HADR_TRANSPORT_FLOW_CONTROL', 'Replication'), \
181 - ('HADR_TRANSPORT_SESSION', 'Replication'), \
182 - ('HADR_WORK_POOL', 'Replication'), \
183 - ('HADR_WORK_QUEUE', 'Replication'), \
184 - ('HADR_XRF_STACK_ACCESS', 'Replication'), \
185 - ('INSTANCE_LOG_RATE_GOVERNOR', 'Log Rate Governor'), \
186 - ('IO_COMPLETION', 'Other Disk IO'), \
187 - ('IO_QUEUE_LIMIT', 'Other Disk IO'), \
188 - ('IO_RETRY', 'Other Disk IO'), \
189 - ('LATCH_DT', 'Latch'), \
190 - ('LATCH_EX', 'Latch'), \
191 - ('LATCH_KP', 'Latch'), \
192 - ('LATCH_NL', 'Latch'), \
193 - ('LATCH_SH', 'Latch'), \
194 - ('LATCH_UP', 'Latch'), \
195 - ('LAZYWRITER_SLEEP', 'Idle'), \
196 - ('LCK_M_BU', 'Lock'), \
197 - ('LCK_M_BU_ABORT_BLOCKERS', 'Lock'), \
198 - ('LCK_M_BU_LOW_PRIORITY', 'Lock'), \
199 - ('LCK_M_IS', 'Lock'), \
200 - ('LCK_M_IS_ABORT_BLOCKERS', 'Lock'), \
201 - ('LCK_M_IS_LOW_PRIORITY', 'Lock'), \
202 - ('LCK_M_IU', 'Lock'), \
203 - ('LCK_M_IU_ABORT_BLOCKERS', 'Lock'), \
204 - ('LCK_M_IU_LOW_PRIORITY', 'Lock'), \
205 - ('LCK_M_IX', 'Lock'), \
206 - ('LCK_M_IX_ABORT_BLOCKERS', 'Lock'), \
207 - ('LCK_M_IX_LOW_PRIORITY', 'Lock'), \
208 - ('LCK_M_RIn_NL', 'Lock'), \
209 - ('LCK_M_RIn_NL_ABORT_BLOCKERS', 'Lock'), \
210 - ('LCK_M_RIn_NL_LOW_PRIORITY', 'Lock'), \
211 - ('LCK_M_RIn_S', 'Lock'), \
212 - ('LCK_M_RIn_S_ABORT_BLOCKERS', 'Lock'), \
213 - ('LCK_M_RIn_S_LOW_PRIORITY', 'Lock'), \
214 - ('LCK_M_RIn_U', 'Lock'), \
215 - ('LCK_M_RIn_U_ABORT_BLOCKERS', 'Lock'), \
216 - ('LCK_M_RIn_U_LOW_PRIORITY', 'Lock'), \
217 - ('LCK_M_RIn_X', 'Lock'), \
218 - ('LCK_M_RIn_X_ABORT_BLOCKERS', 'Lock'), \
219 - ('LCK_M_RIn_X_LOW_PRIORITY', 'Lock'), \
220 - ('LCK_M_RS_S', 'Lock'), \
221 - ('LCK_M_RS_S_ABORT_BLOCKERS', 'Lock'), \
222 - ('LCK_M_RS_S_LOW_PRIORITY', 'Lock'), \
223 - ('LCK_M_RS_U', 'Lock'), \
224 - ('LCK_M_RS_U_ABORT_BLOCKERS', 'Lock'), \
225 - ('LCK_M_RS_U_LOW_PRIORITY', 'Lock'), \
226 - ('LCK_M_RX_S', 'Lock'), \
227 - ('LCK_M_RX_S_ABORT_BLOCKERS', 'Lock'), \
228 - ('LCK_M_RX_S_LOW_PRIORITY', 'Lock'), \
229 - ('LCK_M_RX_U', 'Lock'), \
230 - ('LCK_M_RX_U_ABORT_BLOCKERS', 'Lock'), \
231 - ('LCK_M_RX_U_LOW_PRIORITY', 'Lock'), \
232 - ('LCK_M_RX_X', 'Lock'), \
233 - ('LCK_M_RX_X_ABORT_BLOCKERS', 'Lock'), \
234 - ('LCK_M_RX_X_LOW_PRIORITY', 'Lock'), \
235 - ('LCK_M_S', 'Lock'), \
236 - ('LCK_M_S_ABORT_BLOCKERS', 'Lock'), \
237 - ('LCK_M_S_LOW_PRIORITY', 'Lock'), \
238 - ('LCK_M_SCH_M', 'Lock'), \
239 - ('LCK_M_SCH_M_ABORT_BLOCKERS', 'Lock'), \
240 - ('LCK_M_SCH_M_LOW_PRIORITY', 'Lock'), \
241 - ('LCK_M_SCH_S', 'Lock'), \
242 - ('LCK_M_SCH_S_ABORT_BLOCKERS', 'Lock'), \
243 - ('LCK_M_SCH_S_LOW_PRIORITY', 'Lock'), \
244 - ('LCK_M_SIU', 'Lock'), \
245 - ('LCK_M_SIU_ABORT_BLOCKERS', 'Lock'), \
246 - ('LCK_M_SIU_LOW_PRIORITY', 'Lock'), \
247 - ('LCK_M_SIX', 'Lock'), \
248 - ('LCK_M_SIX_ABORT_BLOCKERS', 'Lock'), \
249 - ('LCK_M_SIX_LOW_PRIORITY', 'Lock'), \
250 - ('LCK_M_U', 'Lock'), \
251 - ('LCK_M_U_ABORT_BLOCKERS', 'Lock'), \
252 - ('LCK_M_U_LOW_PRIORITY', 'Lock'), \
253 - ('LCK_M_UIX', 'Lock'), \
254 - ('LCK_M_UIX_ABORT_BLOCKERS', 'Lock'), \
255 - ('LCK_M_UIX_LOW_PRIORITY', 'Lock'), \
256 - ('LCK_M_X', 'Lock'), \
257 - ('LCK_M_X_ABORT_BLOCKERS', 'Lock'), \
258 - ('LCK_M_X_LOW_PRIORITY', 'Lock'), \
259 - ('LOGBUFFER', 'Tran Log IO'), \
260 - ('LOGMGR', 'Tran Log IO'), \
261 - ('LOGMGR_FLUSH', 'Tran Log IO'), \
262 - ('LOGMGR_PMM_LOG', 'Tran Log IO'), \
263 - ('LOGMGR_QUEUE', 'Idle'), \
264 - ('LOGMGR_RESERVE_APPEND', 'Tran Log IO'), \
265 - ('MEMORY_ALLOCATION_EXT', 'Memory'), \
266 - ('MEMORY_GRANT_UPDATE', 'Memory'), \
267 - ('MSQL_XACT_MGR_MUTEX', 'Transaction'), \
268 - ('MSQL_XACT_MUTEX', 'Transaction'), \
269 - ('MSSEARCH', 'Full Text Search'), \
270 - ('NET_WAITFOR_PACKET', 'Network IO'), \
271 - ('ONDEMAND_TASK_QUEUE', 'Idle'), \
272 - ('PAGEIOLATCH_DT', 'Buffer IO'), \
273 - ('PAGEIOLATCH_EX', 'Buffer IO'), \
274 - ('PAGEIOLATCH_KP', 'Buffer IO'), \
275 - ('PAGEIOLATCH_NL', 'Buffer IO'), \
276 - ('PAGEIOLATCH_SH', 'Buffer IO'), \
277 - ('PAGEIOLATCH_UP', 'Buffer IO'), \
278 - ('PAGELATCH_DT', 'Buffer Latch'), \
279 - ('PAGELATCH_EX', 'Buffer Latch'), \
280 - ('PAGELATCH_KP', 'Buffer Latch'), \
281 - ('PAGELATCH_NL', 'Buffer Latch'), \
282 - ('PAGELATCH_SH', 'Buffer Latch'), \
283 - ('PAGELATCH_UP', 'Buffer Latch'), \
284 - ('POOL_LOG_RATE_GOVERNOR', 'Log Rate Governor'), \
285 - ('PREEMPTIVE_ABR', 'Preemptive'), \
286 - ('PREEMPTIVE_CLOSEBACKUPMEDIA', 'Preemptive'), \
287 - ('PREEMPTIVE_CLOSEBACKUPTAPE', 'Preemptive'), \
288 - ('PREEMPTIVE_CLOSEBACKUPVDIDEVICE', 'Preemptive'), \
289 - ('PREEMPTIVE_CLUSAPI_CLUSTERRESOURCECONTROL', 'Preemptive'), \
290 - ('PREEMPTIVE_COM_COCREATEINSTANCE', 'Preemptive'), \
291 - ('PREEMPTIVE_COM_COGETCLASSOBJECT', 'Preemptive'), \
292 - ('PREEMPTIVE_COM_CREATEACCESSOR', 'Preemptive'), \
293 - ('PREEMPTIVE_COM_DELETEROWS', 'Preemptive'), \
294 - ('PREEMPTIVE_COM_GETCOMMANDTEXT', 'Preemptive'), \
295 - ('PREEMPTIVE_COM_GETDATA', 'Preemptive'), \
296 - ('PREEMPTIVE_COM_GETNEXTROWS', 'Preemptive'), \
297 - ('PREEMPTIVE_COM_GETRESULT', 'Preemptive'), \
298 - ('PREEMPTIVE_COM_GETROWSBYBOOKMARK', 'Preemptive'), \
299 - ('PREEMPTIVE_COM_LBFLUSH', 'Preemptive'), \
300 - ('PREEMPTIVE_COM_LBLOCKREGION', 'Preemptive'), \
301 - ('PREEMPTIVE_COM_LBREADAT', 'Preemptive'), \
302 - ('PREEMPTIVE_COM_LBSETSIZE', 'Preemptive'), \
303 - ('PREEMPTIVE_COM_LBSTAT', 'Preemptive'), \
304 - ('PREEMPTIVE_COM_LBUNLOCKREGION', 'Preemptive'), \
305 - ('PREEMPTIVE_COM_LBWRITEAT', 'Preemptive'), \
306 - ('PREEMPTIVE_COM_QUERYINTERFACE', 'Preemptive'), \
307 - ('PREEMPTIVE_COM_RELEASE', 'Preemptive'), \
308 - ('PREEMPTIVE_COM_RELEASEACCESSOR', 'Preemptive'), \
309 - ('PREEMPTIVE_COM_RELEASEROWS', 'Preemptive'), \
310 - ('PREEMPTIVE_COM_RELEASESESSION', 'Preemptive'), \
311 - ('PREEMPTIVE_COM_RESTARTPOSITION', 'Preemptive'), \
312 - ('PREEMPTIVE_COM_SEQSTRMREAD', 'Preemptive'), \
313 - ('PREEMPTIVE_COM_SEQSTRMREADANDWRITE', 'Preemptive'), \
314 - ('PREEMPTIVE_COM_SETDATAFAILURE', 'Preemptive'), \
315 - ('PREEMPTIVE_COM_SETPARAMETERINFO', 'Preemptive'), \
316 - ('PREEMPTIVE_COM_SETPARAMETERPROPERTIES', 'Preemptive'), \
317 - ('PREEMPTIVE_COM_STRMLOCKREGION', 'Preemptive'), \
318 - ('PREEMPTIVE_COM_STRMSEEKANDREAD', 'Preemptive'), \
319 - ('PREEMPTIVE_COM_STRMSEEKANDWRITE', 'Preemptive'), \
320 - ('PREEMPTIVE_COM_STRMSETSIZE', 'Preemptive'), \
321 - ('PREEMPTIVE_COM_STRMSTAT', 'Preemptive'), \
322 - ('PREEMPTIVE_COM_STRMUNLOCKREGION', 'Preemptive'), \
323 - ('PREEMPTIVE_CONSOLEWRITE', 'Preemptive'), \
324 - ('PREEMPTIVE_CREATEPARAM', 'Preemptive'), \
325 - ('PREEMPTIVE_DEBUG', 'Preemptive'), \
326 - ('PREEMPTIVE_DFSADDLINK', 'Preemptive'), \
327 - ('PREEMPTIVE_DFSLINKEXISTCHECK', 'Preemptive'), \
328 - ('PREEMPTIVE_DFSLINKHEALTHCHECK', 'Preemptive'), \
329 - ('PREEMPTIVE_DFSREMOVELINK', 'Preemptive'), \
330 - ('PREEMPTIVE_DFSREMOVEROOT', 'Preemptive'), \
331 - ('PREEMPTIVE_DFSROOTFOLDERCHECK', 'Preemptive'), \
332 - ('PREEMPTIVE_DFSROOTINIT', 'Preemptive'), \
333 - ('PREEMPTIVE_DFSROOTSHARECHECK', 'Preemptive'), \
334 - ('PREEMPTIVE_DTC_ABORT', 'Preemptive'), \
335 - ('PREEMPTIVE_DTC_ABORTREQUESTDONE', 'Preemptive'), \
336 - ('PREEMPTIVE_DTC_BEGINTRANSACTION', 'Preemptive'), \
337 - ('PREEMPTIVE_DTC_COMMITREQUESTDONE', 'Preemptive'), \
338 - ('PREEMPTIVE_DTC_ENLIST', 'Preemptive'), \
339 - ('PREEMPTIVE_DTC_PREPAREREQUESTDONE', 'Preemptive'), \
340 - ('PREEMPTIVE_FILESIZEGET', 'Preemptive'), \
341 - ('PREEMPTIVE_FSAOLEDB_ABORTTRANSACTION', 'Preemptive'), \
342 - ('PREEMPTIVE_FSAOLEDB_COMMITTRANSACTION', 'Preemptive'), \
343 - ('PREEMPTIVE_FSAOLEDB_STARTTRANSACTION', 'Preemptive'), \
344 - ('PREEMPTIVE_FSRECOVER_UNCONDITIONALUNDO', 'Preemptive'), \
345 - ('PREEMPTIVE_GETRMINFO', 'Preemptive'), \
346 - ('PREEMPTIVE_HADR_LEASE_MECHANISM', 'Preemptive'), \
347 - ('PREEMPTIVE_HTTP_EVENT_WAIT', 'Preemptive'), \
348 - ('PREEMPTIVE_HTTP_REQUEST', 'Preemptive'), \
349 - ('PREEMPTIVE_LOCKMONITOR', 'Preemptive'), \
350 - ('PREEMPTIVE_MSS_RELEASE', 'Preemptive'), \
351 - ('PREEMPTIVE_ODBCOPS', 'Preemptive'), \
352 - ('PREEMPTIVE_OLE_UNINIT', 'Preemptive'), \
353 - ('PREEMPTIVE_OLEDB_ABORTORCOMMITTRAN', 'Preemptive'), \
354 - ('PREEMPTIVE_OLEDB_ABORTTRAN', 'Preemptive'), \
355 - ('PREEMPTIVE_OLEDB_GETDATASOURCE', 'Preemptive'), \
356 - ('PREEMPTIVE_OLEDB_GETLITERALINFO', 'Preemptive'), \
357 - ('PREEMPTIVE_OLEDB_GETPROPERTIES', 'Preemptive'), \
358 - ('PREEMPTIVE_OLEDB_GETPROPERTYINFO', 'Preemptive'), \
359 - ('PREEMPTIVE_OLEDB_GETSCHEMALOCK', 'Preemptive'), \
360 - ('PREEMPTIVE_OLEDB_JOINTRANSACTION', 'Preemptive'), \
361 - ('PREEMPTIVE_OLEDB_RELEASE', 'Preemptive'), \
362 - ('PREEMPTIVE_OLEDB_SETPROPERTIES', 'Preemptive'), \
363 - ('PREEMPTIVE_OLEDBOPS', 'Preemptive'), \
364 - ('PREEMPTIVE_OS_ACCEPTSECURITYCONTEXT', 'Preemptive'), \
365 - ('PREEMPTIVE_OS_ACQUIRECREDENTIALSHANDLE', 'Preemptive'), \
366 - ('PREEMPTIVE_OS_AUTHENTICATIONOPS', 'Preemptive'), \
367 - ('PREEMPTIVE_OS_AUTHORIZATIONOPS', 'Preemptive'), \
368 - ('PREEMPTIVE_OS_AUTHZGETINFORMATIONFROMCONTEXT', 'Preemptive'), \
369 - ('PREEMPTIVE_OS_AUTHZINITIALIZECONTEXTFROMSID', 'Preemptive'), \
370 - ('PREEMPTIVE_OS_AUTHZINITIALIZERESOURCEMANAGER', 'Preemptive'), \
371 - ('PREEMPTIVE_OS_BACKUPREAD', 'Preemptive'), \
372 - ('PREEMPTIVE_OS_CLOSEHANDLE', 'Preemptive'), \
373 - ('PREEMPTIVE_OS_CLUSTEROPS', 'Preemptive'), \
374 - ('PREEMPTIVE_OS_COMOPS', 'Preemptive'), \
375 - ('PREEMPTIVE_OS_COMPLETEAUTHTOKEN', 'Preemptive'), \
376 - ('PREEMPTIVE_OS_COPYFILE', 'Preemptive'), \
377 - ('PREEMPTIVE_OS_CREATEDIRECTORY', 'Preemptive'), \
378 - ('PREEMPTIVE_OS_CREATEFILE', 'Preemptive'), \
379 - ('PREEMPTIVE_OS_CRYPTACQUIRECONTEXT', 'Preemptive'), \
380 - ('PREEMPTIVE_OS_CRYPTIMPORTKEY', 'Preemptive'), \
381 - ('PREEMPTIVE_OS_CRYPTOPS', 'Preemptive'), \
382 - ('PREEMPTIVE_OS_DECRYPTMESSAGE', 'Preemptive'), \
383 - ('PREEMPTIVE_OS_DELETEFILE', 'Preemptive'), \
384 - ('PREEMPTIVE_OS_DELETESECURITYCONTEXT', 'Preemptive'), \
385 - ('PREEMPTIVE_OS_DEVICEIOCONTROL', 'Preemptive'), \
386 - ('PREEMPTIVE_OS_DEVICEOPS', 'Preemptive'), \
387 - ('PREEMPTIVE_OS_DIRSVC_NETWORKOPS', 'Preemptive'), \
388 - ('PREEMPTIVE_OS_DISCONNECTNAMEDPIPE', 'Preemptive'), \
389 - ('PREEMPTIVE_OS_DOMAINSERVICESOPS', 'Preemptive'), \
390 - ('PREEMPTIVE_OS_DSGETDCNAME', 'Preemptive'), \
391 - ('PREEMPTIVE_OS_DTCOPS', 'Preemptive'), \
392 - ('PREEMPTIVE_OS_ENCRYPTMESSAGE', 'Preemptive'), \
393 - ('PREEMPTIVE_OS_FILEOPS', 'Preemptive'), \
394 - ('PREEMPTIVE_OS_FINDFILE', 'Preemptive'), \
395 - ('PREEMPTIVE_OS_FLUSHFILEBUFFERS', 'Preemptive'), \
396 - ('PREEMPTIVE_OS_FORMATMESSAGE', 'Preemptive'), \
397 - ('PREEMPTIVE_OS_FREECREDENTIALSHANDLE', 'Preemptive'), \
398 - ('PREEMPTIVE_OS_FREELIBRARY', 'Preemptive'), \
399 - ('PREEMPTIVE_OS_GENERICOPS', 'Preemptive'), \
400 - ('PREEMPTIVE_OS_GETADDRINFO', 'Preemptive'), \
401 - ('PREEMPTIVE_OS_GETCOMPRESSEDFILESIZE', 'Preemptive'), \
402 - ('PREEMPTIVE_OS_GETDISKFREESPACE', 'Preemptive'), \
403 - ('PREEMPTIVE_OS_GETFILEATTRIBUTES', 'Preemptive'), \
404 - ('PREEMPTIVE_OS_GETFILESIZE', 'Preemptive'), \
405 - ('PREEMPTIVE_OS_GETFINALFILEPATHBYHANDLE', 'Preemptive'), \
406 - ('PREEMPTIVE_OS_GETLONGPATHNAME', 'Preemptive'), \
407 - ('PREEMPTIVE_OS_GETPROCADDRESS', 'Preemptive'), \
408 - ('PREEMPTIVE_OS_GETVOLUMENAMEFORVOLUMEMOUNTPOINT', 'Preemptive'), \
409 - ('PREEMPTIVE_OS_GETVOLUMEPATHNAME', 'Preemptive'), \
410 - ('PREEMPTIVE_OS_INITIALIZESECURITYCONTEXT', 'Preemptive'), \
411 - ('PREEMPTIVE_OS_LIBRARYOPS', 'Preemptive'), \
412 - ('PREEMPTIVE_OS_LOADLIBRARY', 'Preemptive'), \
413 - ('PREEMPTIVE_OS_LOGONUSER', 'Preemptive'), \
414 - ('PREEMPTIVE_OS_LOOKUPACCOUNTSID', 'Preemptive'), \
415 - ('PREEMPTIVE_OS_MESSAGEQUEUEOPS', 'Preemptive'), \
416 - ('PREEMPTIVE_OS_MOVEFILE', 'Preemptive'), \
417 - ('PREEMPTIVE_OS_NETGROUPGETUSERS', 'Preemptive'), \
418 - ('PREEMPTIVE_OS_NETLOCALGROUPGETMEMBERS', 'Preemptive'), \
419 - ('PREEMPTIVE_OS_NETUSERGETGROUPS', 'Preemptive'), \
420 - ('PREEMPTIVE_OS_NETUSERGETLOCALGROUPS', 'Preemptive'), \
421 - ('PREEMPTIVE_OS_NETUSERMODALSGET', 'Preemptive'), \
422 - ('PREEMPTIVE_OS_NETVALIDATEPASSWORDPOLICY', 'Preemptive'), \
423 - ('PREEMPTIVE_OS_NETVALIDATEPASSWORDPOLICYFREE', 'Preemptive'), \
424 - ('PREEMPTIVE_OS_OPENDIRECTORY', 'Preemptive'), \
425 - ('PREEMPTIVE_OS_PDH_WMI_INIT', 'Preemptive'), \
426 - ('PREEMPTIVE_OS_PIPEOPS', 'Preemptive'), \
427 - ('PREEMPTIVE_OS_PROCESSOPS', 'Preemptive'), \
428 - ('PREEMPTIVE_OS_QUERYCONTEXTATTRIBUTES', 'Preemptive'), \
429 - ('PREEMPTIVE_OS_QUERYREGISTRY', 'Preemptive'), \
430 - ('PREEMPTIVE_OS_QUERYSECURITYCONTEXTTOKEN', 'Preemptive'), \
431 - ('PREEMPTIVE_OS_REMOVEDIRECTORY', 'Preemptive'), \
432 - ('PREEMPTIVE_OS_REPORTEVENT', 'Preemptive'), \
433 - ('PREEMPTIVE_OS_REVERTTOSELF', 'Preemptive'), \
434 - ('PREEMPTIVE_OS_RSFXDEVICEOPS', 'Preemptive'), \
435 - ('PREEMPTIVE_OS_SECURITYOPS', 'Preemptive'), \
436 - ('PREEMPTIVE_OS_SERVICEOPS', 'Preemptive'), \
437 - ('PREEMPTIVE_OS_SETENDOFFILE', 'Preemptive'), \
438 - ('PREEMPTIVE_OS_SETFILEPOINTER', 'Preemptive'), \
439 - ('PREEMPTIVE_OS_SETFILEVALIDDATA', 'Preemptive'), \
440 - ('PREEMPTIVE_OS_SETNAMEDSECURITYINFO', 'Preemptive'), \
441 - ('PREEMPTIVE_OS_SQLCLROPS', 'Preemptive'), \
442 - ('PREEMPTIVE_OS_SQMLAUNCH', 'Preemptive'), \
443 - ('PREEMPTIVE_OS_VERIFYSIGNATURE', 'Preemptive'), \
444 - ('PREEMPTIVE_OS_VERIFYTRUST', 'Preemptive'), \
445 - ('PREEMPTIVE_OS_VSSOPS', 'Preemptive'), \
446 - ('PREEMPTIVE_OS_WAITFORSINGLEOBJECT', 'Preemptive'), \
447 - ('PREEMPTIVE_OS_WINSOCKOPS', 'Preemptive'), \
448 - ('PREEMPTIVE_OS_WRITEFILE', 'Preemptive'), \
449 - ('PREEMPTIVE_OS_WRITEFILEGATHER', 'Preemptive'), \
450 - ('PREEMPTIVE_OS_WSASETLASTERROR', 'Preemptive'), \
451 - ('PREEMPTIVE_REENLIST', 'Preemptive'), \
452 - ('PREEMPTIVE_RESIZELOG', 'Preemptive'), \
453 - ('PREEMPTIVE_ROLLFORWARDREDO', 'Preemptive'), \
454 - ('PREEMPTIVE_ROLLFORWARDUNDO', 'Preemptive'), \
455 - ('PREEMPTIVE_SB_STOPENDPOINT', 'Preemptive'), \
456 - ('PREEMPTIVE_SERVER_STARTUP', 'Preemptive'), \
457 - ('PREEMPTIVE_SETRMINFO', 'Preemptive'), \
458 - ('PREEMPTIVE_SHAREDMEM_GETDATA', 'Preemptive'), \
459 - ('PREEMPTIVE_SNIOPEN', 'Preemptive'), \
460 - ('PREEMPTIVE_SOSHOST', 'Preemptive'), \
461 - ('PREEMPTIVE_SOSTESTING', 'Preemptive'), \
462 - ('PREEMPTIVE_SP_SERVER_DIAGNOSTICS', 'Preemptive'), \
463 - ('PREEMPTIVE_STARTRM', 'Preemptive'), \
464 - ('PREEMPTIVE_STREAMFCB_CHECKPOINT', 'Preemptive'), \
465 - ('PREEMPTIVE_STREAMFCB_RECOVER', 'Preemptive'), \
466 - ('PREEMPTIVE_STRESSDRIVER', 'Preemptive'), \
467 - ('PREEMPTIVE_TESTING', 'Preemptive'), \
468 - ('PREEMPTIVE_TRANSIMPORT', 'Preemptive'), \
469 - ('PREEMPTIVE_UNMARSHALPROPAGATIONTOKEN', 'Preemptive'), \
470 - ('PREEMPTIVE_VSS_CREATESNAPSHOT', 'Preemptive'), \
471 - ('PREEMPTIVE_VSS_CREATEVOLUMESNAPSHOT', 'Preemptive'), \
472 - ('PREEMPTIVE_XE_CALLBACKEXECUTE', 'Preemptive'), \
473 - ('PREEMPTIVE_XE_CX_FILE_OPEN', 'Preemptive'), \
474 - ('PREEMPTIVE_XE_CX_HTTP_CALL', 'Preemptive'), \
475 - ('PREEMPTIVE_XE_DISPATCHER', 'Preemptive'), \
476 - ('PREEMPTIVE_XE_ENGINEINIT', 'Preemptive'), \
477 - ('PREEMPTIVE_XE_GETTARGETSTATE', 'Preemptive'), \
478 - ('PREEMPTIVE_XE_SESSIONCOMMIT', 'Preemptive'), \
479 - ('PREEMPTIVE_XE_TARGETFINALIZE', 'Preemptive'), \
480 - ('PREEMPTIVE_XE_TARGETINIT', 'Preemptive'), \
481 - ('PREEMPTIVE_XE_TIMERRUN', 'Preemptive'), \
482 - ('PREEMPTIVE_XETESTING', 'Preemptive'), \
483 - ('PWAIT_HADR_ACTION_COMPLETED', 'Replication'), \
484 - ('PWAIT_HADR_CHANGE_NOTIFIER_TERMINATION_SYNC', 'Replication'), \
485 - ('PWAIT_HADR_CLUSTER_INTEGRATION', 'Replication'), \
486 - ('PWAIT_HADR_FAILOVER_COMPLETED', 'Replication'), \
487 - ('PWAIT_HADR_JOIN', 'Replication'), \
488 - ('PWAIT_HADR_OFFLINE_COMPLETED', 'Replication'), \
489 - ('PWAIT_HADR_ONLINE_COMPLETED', 'Replication'), \
490 - ('PWAIT_HADR_POST_ONLINE_COMPLETED', 'Replication'), \
491 - ('PWAIT_HADR_SERVER_READY_CONNECTIONS', 'Replication'), \
492 - ('PWAIT_HADR_WORKITEM_COMPLETED', 'Replication'), \
493 - ('PWAIT_HADRSIM', 'Replication'), \
494 - ('PWAIT_RESOURCE_SEMAPHORE_FT_PARALLEL_QUERY_SYNC', 'Full Text Search'), \
495 - ('QUERY_TRACEOUT', 'Tracing'), \
496 - ('REPL_CACHE_ACCESS', 'Replication'), \
497 - ('REPL_HISTORYCACHE_ACCESS', 'Replication'), \
498 - ('REPL_SCHEMA_ACCESS', 'Replication'), \
499 - ('REPL_TRANFSINFO_ACCESS', 'Replication'), \
500 - ('REPL_TRANHASHTABLE_ACCESS', 'Replication'), \
501 - ('REPL_TRANTEXTINFO_ACCESS', 'Replication'), \
502 - ('REPLICA_WRITES', 'Replication'), \
503 - ('REQUEST_FOR_DEADLOCK_SEARCH', 'Idle'), \
504 - ('RESERVED_MEMORY_ALLOCATION_EXT', 'Memory'), \
505 - ('RESOURCE_SEMAPHORE', 'Memory'), \
506 - ('RESOURCE_SEMAPHORE_QUERY_COMPILE', 'Compilation'), \
507 - ('SLEEP_BPOOL_FLUSH', 'Idle'), \
508 - ('SLEEP_BUFFERPOOL_HELPLW', 'Idle'), \
509 - ('SLEEP_DBSTARTUP', 'Idle'), \
510 - ('SLEEP_DCOMSTARTUP', 'Idle'), \
511 - ('SLEEP_MASTERDBREADY', 'Idle'), \
512 - ('SLEEP_MASTERMDREADY', 'Idle'), \
513 - ('SLEEP_MASTERUPGRADED', 'Idle'), \
514 - ('SLEEP_MEMORYPOOL_ALLOCATEPAGES', 'Idle'), \
515 - ('SLEEP_MSDBSTARTUP', 'Idle'), \
516 - ('SLEEP_RETRY_VIRTUALALLOC', 'Idle'), \
517 - ('SLEEP_SYSTEMTASK', 'Idle'), \
518 - ('SLEEP_TASK', 'Idle'), \
519 - ('SLEEP_TEMPDBSTARTUP', 'Idle'), \
520 - ('SLEEP_WORKSPACE_ALLOCATEPAGE', 'Idle'), \
521 - ('SOS_SCHEDULER_YIELD', 'CPU'), \
522 - ('SQLCLR_APPDOMAIN', 'SQL CLR'), \
523 - ('SQLCLR_ASSEMBLY', 'SQL CLR'), \
524 - ('SQLCLR_DEADLOCK_DETECTION', 'SQL CLR'), \
525 - ('SQLCLR_QUANTUM_PUNISHMENT', 'SQL CLR'), \
526 - ('SQLTRACE_BUFFER_FLUSH', 'Idle'), \
527 - ('SQLTRACE_FILE_BUFFER', 'Tracing'), \
528 - ('SQLTRACE_FILE_READ_IO_COMPLETION', 'Tracing'), \
529 - ('SQLTRACE_FILE_WRITE_IO_COMPLETION', 'Tracing'), \
530 - ('SQLTRACE_INCREMENTAL_FLUSH_SLEEP', 'Idle'), \
531 - ('SQLTRACE_PENDING_BUFFER_WRITERS', 'Tracing'), \
532 - ('SQLTRACE_SHUTDOWN', 'Tracing'), \
533 - ('SQLTRACE_WAIT_ENTRIES', 'Idle'), \
534 - ('THREADPOOL', 'Worker Thread'), \
535 - ('TRACE_EVTNOTIF', 'Tracing'), \
536 - ('TRACEWRITE', 'Tracing'), \
537 - ('TRAN_MARKLATCH_DT', 'Transaction'), \
538 - ('TRAN_MARKLATCH_EX', 'Transaction'), \
539 - ('TRAN_MARKLATCH_KP', 'Transaction'), \
540 - ('TRAN_MARKLATCH_NL', 'Transaction'), \
541 - ('TRAN_MARKLATCH_SH', 'Transaction'), \
542 - ('TRAN_MARKLATCH_UP', 'Transaction'), \
543 - ('TRANSACTION_MUTEX', 'Transaction'), \
544 - ('WAIT_FOR_RESULTS', 'User Wait'), \
545 - ('WAITFOR', 'User Wait'), \
546 - ('WRITE_COMPLETION', 'Other Disk IO'), \
547 - ('WRITELOG', 'Tran Log IO'), \
548 - ('XACT_OWN_TRANSACTION', 'Transaction'), \
549 - ('XACT_RECLAIM_SESSION', 'Transaction'), \
550 - ('XACTLOCKINFO', 'Transaction'), \
551 - ('XACTWORKSPACE_MUTEX', 'Transaction'), \
552 - ('XE_DISPATCHER_WAIT', 'Idle'), \
553 - ('XE_TIMER_EVENT', 'Idle')) AS wc([wait_type], [wait_category]) ON ws.[wait_type] = \
554 - wc.[wait_type] WHERE ws \
555 - .[wait_type] NOT IN( \
556 - N'BROKER_EVENTHANDLER', \
557 - N'BROKER_RECEIVE_WAITFOR', \
558 - N'BROKER_TASK_STOP', \
559 - N'BROKER_TO_FLUSH', \
560 - N'BROKER_TRANSMITTER', \
561 - N'CHECKPOINT_QUEUE', \
562 - N'CHKPT', \
563 - N'CLR_AUTO_EVENT', \
564 - N'CLR_MANUAL_EVENT', \
565 - N'CLR_SEMAPHORE', \
566 - N'DBMIRROR_DBM_EVENT', \
567 - N'DBMIRROR_EVENTS_QUEUE', \
568 - N'DBMIRROR_WORKER_QUEUE', \
569 - N'DBMIRRORING_CMD', \
570 - N'DIRTY_PAGE_POLL', \
571 - N'DISPATCHER_QUEUE_SEMAPHORE', \
572 - N'EXECSYNC', \
573 - N'FSAGENT', \
574 - N'FT_IFTS_SCHEDULER_IDLE_WAIT', \
575 - N'FT_IFTSHC_MUTEX', \
576 - N'HADR_CLUSAPI_CALL', \
577 - N'HADR_FILESTREAM_IOMGR_IOCOMPLETION', \
578 - N'HADR_LOGCAPTURE_WAIT', \
579 - N'HADR_NOTIFICATION_DEQUEUE', \
580 - N'HADR_TIMER_TASK', \
581 - N'HADR_WORK_QUEUE', \
582 - N'KSOURCE_WAKEUP', \
583 - N'LAZYWRITER_SLEEP', \
584 - N'LOGMGR_QUEUE', \
585 - N'MEMORY_ALLOCATION_EXT', \
586 - N'ONDEMAND_TASK_QUEUE', \
587 - N'PARALLEL_REDO_WORKER_WAIT_WORK', \
588 - N'PREEMPTIVE_HADR_LEASE_MECHANISM', \
589 - N'PREEMPTIVE_SP_SERVER_DIAGNOSTICS', \
590 - N'PREEMPTIVE_OS_LIBRARYOPS', \
591 - N'PREEMPTIVE_OS_COMOPS', \
592 - N'PREEMPTIVE_OS_CRYPTOPS', \
593 - N'PREEMPTIVE_OS_PIPEOPS', \
594 - 'PREEMPTIVE_OS_GENERICOPS', \
595 - N'PREEMPTIVE_OS_VERIFYTRUST', \
596 - N'PREEMPTIVE_OS_DEVICEOPS', \
597 - N'PREEMPTIVE_XE_CALLBACKEXECUTE', \
598 - N'PREEMPTIVE_XE_DISPATCHER', \
599 - N'PREEMPTIVE_XE_GETTARGETSTATE', \
600 - N'PREEMPTIVE_XE_SESSIONCOMMIT', \
601 - N'PREEMPTIVE_XE_TARGETINIT', \
602 - N'PREEMPTIVE_XE_TARGETFINALIZE', \
603 - N'PWAIT_ALL_COMPONENTS_INITIALIZED', \
604 - N'PWAIT_DIRECTLOGCONSUMER_GETNEXT', \
605 - N'QDS_PERSIST_TASK_MAIN_LOOP_SLEEP', \
606 - N'QDS_ASYNC_QUEUE', \
607 - N'QDS_CLEANUP_STALE_QUERIES_TASK_MAIN_LOOP_SLEEP', \
608 - N'REQUEST_FOR_DEADLOCK_SEARCH', \
609 - N'RESOURCE_QUEUE', \
610 - N'SERVER_IDLE_CHECK', \
611 - N'SLEEP_BPOOL_FLUSH', \
612 - N'SLEEP_DBSTARTUP', \
613 - N'SLEEP_DCOMSTARTUP', \
614 - N'SLEEP_MASTERDBREADY', \
615 - N'SLEEP_MASTERMDREADY', \
616 - N'SLEEP_MASTERUPGRADED', \
617 - N'SLEEP_MSDBSTARTUP', \
618 - N'SLEEP_SYSTEMTASK', \
619 - N'SLEEP_TASK', \
620 - N'SLEEP_TEMPDBSTARTUP', \
621 - N'SNI_HTTP_ACCEPT', \
622 - N'SP_SERVER_DIAGNOSTICS_SLEEP', \
623 - N'SQLTRACE_BUFFER_FLUSH', \
624 - N'SQLTRACE_INCREMENTAL_FLUSH_SLEEP', \
625 - N'SQLTRACE_WAIT_ENTRIES', \
626 - N'WAIT_FOR_RESULTS', \
627 - N'WAITFOR', \
628 - N'WAITFOR_TASKSHUTDOWN', \
629 - N'WAIT_XTP_HOST_WAIT', \
630 - N'WAIT_XTP_OFFLINE_CKPT_NEW_LOG', \
631 - N'WAIT_XTP_CKPT_CLOSE', \
632 - N'XE_BUFFERMGR_ALLPROCESSED_EVENT', \
633 - N'XE_DISPATCHER_JOIN', \
634 - N'XE_DISPATCHER_WAIT', \
635 - N'XE_LIVE_TARGET_TVF', \
636 - N'XE_TIMER_EVENT', \
637 - N'SOS_WORK_DISPATCHER', \
638 - 'RESERVED_MEMORY_ALLOCATION_EXT') AND ws.[waiting_tasks_count] > 0 AND ws.[wait_time_ms] > 100;"
639 -
640 -#ifndef MEGA_FACTOR
641 -#define MEGA_FACTOR (1048576) // 1024 * 1024
642 -#endif
643 -// https://learn.microsoft.com/en-us/sql/sql-server/install/instance-configuration?view=sql-server-ver16
644 -#define NETDATA_MAX_INSTANCE_NAME (32)
645 -#define NETDATA_MAX_INSTANCE_OBJECT (128)
646 -// https://learn.microsoft.com/en-us/previous-versions/sql/sql-server-2008-r2/ms191240(v=sql.105)#sysname
647 -#define SQLSERVER_MAX_NAME_LENGTH NETDATA_MAX_INSTANCE_OBJECT
648 -#define NETDATA_MSSQL_NEXT_TRY (60)
649 -
650 -struct netdata_mssql_conn {
651 - const char *instance;
652 - const char *driver;
653 - const char *server;
654 - const char *address;
655 - const char *username;
656 - const char *password;
657 - int instances;
658 - bool windows_auth;
659 - bool trust_server_certificate;
660 - bool is_sqlexpress;
661 -
662 - SQLCHAR *connectionString;
663 -
664 - SQLHENV netdataSQLEnv;
665 - SQLHDBC netdataSQLHDBc;
666 -
667 - SQLHSTMT checkPermSTMT;
668 - SQLHSTMT databaseListSTMT;
669 - SQLHSTMT dataFileSizeSTMT;
670 - SQLHSTMT dbPerfCounterSTMT;
671 - SQLHSTMT dbInstanceTransactionSTMT;
672 - SQLHSTMT dbWaitsSTMT;
673 - SQLHSTMT dbLocksSTMT;
674 - SQLHSTMT dbSQLState;
675 - SQLHSTMT dbSQLJobs;
676 - SQLHSTMT dbSQLConnections;
677 - SQLHSTMT dbSQLBlockedProcesses;
678 - SQLHSTMT dbReplicationPublisher;
679 -
680 - BOOL collect_transactions;
681 - BOOL collect_waits;
682 - BOOL collect_locks;
683 - BOOL collect_replication;
684 - BOOL collect_jobs;
685 - BOOL collect_buffer;
686 - BOOL collect_data_size;
687 - BOOL collect_user_connections;
688 - BOOL collect_blocked_processes;
689 -
690 - BOOL is_connected;
691 -};
692 -
693 -enum netdata_mssql_metrics {
694 - NETDATA_MSSQL_GENERAL_STATS,
695 - NETDATA_MSSQL_SQL_ERRORS,
696 - NETDATA_MSSQL_MEMORY,
697 - NETDATA_MSSQL_SQL_STATS,
698 - NETDATA_MSSQL_ACCESS_METHODS,
699 -
700 - NETDATA_MSSQL_DATABASE,
701 - NETDATA_MSSQL_LOCKS,
702 - NETDATA_MSSQL_WAITS,
703 - NETDATA_MSSQL_BUFFER_MANAGEMENT,
704 - NETDATA_MSSQL_JOBS,
705 - NETDATA_USER_CONNECTIONS,
706 - NETDATA_BLOCKED_PROCESS,
707 -
708 - NETDATA_MSSQL_METRICS_END
709 -};
710 -
711 -struct mssql_db_waits {
712 - const char *wait_type;
713 - const char *wait_category;
714 -
715 - RRDSET *st_total_wait;
716 - RRDDIM *rd_total_wait;
717 -
718 - RRDSET *st_resource_wait_msec;
719 - RRDDIM *rd_resource_wait_msec;
720 -
721 - RRDSET *st_signal_wait_msec;
722 - RRDDIM *rd_signal_wait_msec;
723 -
724 - RRDSET *st_max_wait_time_msec;
725 - RRDDIM *rd_max_wait_time_msec;
726 -
727 - RRDSET *st_waiting_tasks;
728 - RRDDIM *rd_waiting_tasks;
729 -
730 - COUNTER_DATA MSSQLDatabaseTotalWait;
731 - COUNTER_DATA MSSQLDatabaseResourceWaitMSec;
732 - COUNTER_DATA MSSQLDatabaseSignalWaitMSec;
733 - COUNTER_DATA MSSQLDatabaseMaxWaitTimeMSec;
734 - COUNTER_DATA MSSQLDatabaseWaitingTasks;
735 -};
736 -
737 -// https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-replmonitorhelppublication-transact-sql?view=sql-server-ver17
738 -struct mssql_publisher_publication {
739 - struct mssql_instance *parent;
740 -
741 - // Lables
742 - char *publisher;
743 - char *publication;
744 - char *db;
745 - int type;
746 -
747 - // Charts
748 - int status;
749 - int warning;
750 -
751 - int avg_latency;
752 -
753 - int retention;
754 -
755 - int subscriptioncount;
756 - int runningdistagentcount;
757 -
758 - int average_runspeedPerf;
759 -
760 - RRDSET *st_publisher_status;
761 - RRDDIM *rd_publisher_status_started;
762 - RRDDIM *rd_publisher_status_successed;
763 - RRDDIM *rd_publisher_status_in_progress;
764 - RRDDIM *rd_publisher_status_idle;
765 - RRDDIM *rd_publisher_status_retrying;
766 - RRDDIM *rd_publisher_status_failed;
767 -
768 - RRDSET *st_warning;
769 - RRDDIM *rd_warning_expiration;
770 - RRDDIM *rd_warning_latency;
771 - RRDDIM *rd_warning_mergeeexpiration;
772 - RRDDIM *rd_warning_mergefastduration;
773 - RRDDIM *rd_warning_mergelowduration;
774 - RRDDIM *rd_warning_mergefastrunspeed;
775 - RRDDIM *rd_warning_mergelowrunspeed;
776 -
777 - RRDSET *st_avg_latency;
778 - RRDDIM *rd_avg_latency;
779 -
780 - RRDSET *st_retention;
781 - RRDDIM *rd_retention;
782 -
783 - RRDSET *st_subscription_count;
784 - RRDDIM *rd_subscription_count;
785 -
786 - RRDSET *st_running_agent;
787 - RRDDIM *rd_running_agent;
788 -
789 - RRDSET *st_synchronization_time;
790 - RRDDIM *rd_synchronization_time;
791 -};
792 -
793 -struct mssql_instance {
794 - char *instanceID;
795 - int update_every;
796 -
797 - struct netdata_mssql_conn *conn;
798 -
799 - char *objectName[NETDATA_MSSQL_METRICS_END];
800 -
801 - RRDSET *st_user_connections;
802 - RRDDIM *rd_user_connections;
803 -
804 - RRDSET *st_session_connections;
805 - RRDDIM *rd_session_connections;
806 -
807 - RRDSET *st_process_blocked;
808 - RRDDIM *rd_process_blocked;
809 -
810 - RRDSET *st_stats_auto_param;
811 - RRDDIM *rd_stats_auto_param;
812 -
813 - RRDSET *st_stats_batch_request;
814 - RRDDIM *rd_stats_batch_request;
815 -
816 - RRDSET *st_stats_safe_auto;
817 - RRDDIM *rd_stats_safe_auto;
818 -
819 - RRDSET *st_access_method_page_splits;
820 - RRDDIM *rd_access_method_page_splits;
821 -
822 - RRDSET *st_sql_errors;
823 - RRDDIM *rd_sql_errors;
824 -
825 - DICTIONARY *locks_instances;
826 -
827 - DICTIONARY *databases;
828 - DICTIONARY *sysjobs;
829 - DICTIONARY *publisher_publication;
830 -
831 - RRDSET *st_conn_memory;
832 - RRDDIM *rd_conn_memory;
833 -
834 - RRDSET *st_ext_benefit_mem;
835 - RRDDIM *rd_ext_benefit_mem;
836 -
837 - RRDSET *st_pending_mem_grant;
838 - RRDDIM *rd_pending_mem_grant;
839 -
840 - RRDSET *st_mem_tot_server;
841 - RRDDIM *rd_mem_tot_server;
842 -
843 - DICTIONARY *waits;
844 -
845 - COUNTER_DATA MSSQLAccessMethodPageSplits;
846 - COUNTER_DATA MSSQLBlockedProcesses;
847 - COUNTER_DATA MSSQLUserConnections;
848 - COUNTER_DATA MSSQLSessionConnections;
849 - COUNTER_DATA MSSQLConnectionMemoryBytes;
850 - COUNTER_DATA MSSQLExternalBenefitOfMemory;
851 - COUNTER_DATA MSSQLPendingMemoryGrants;
852 - COUNTER_DATA MSSQLSQLErrorsTotal;
853 - COUNTER_DATA MSSQLTotalServerMemory;
854 - COUNTER_DATA MSSQLStatsAutoParameterization;
855 - COUNTER_DATA MSSQLStatsBatchRequests;
856 - COUNTER_DATA MSSQLStatSafeAutoParameterization;
857 -};
858 -
859 -struct mssql_lock_instance {
860 - struct mssql_instance *parent;
861 -
862 - char *resourceID;
863 -
864 - COUNTER_DATA lockWait;
865 - COUNTER_DATA deadLocks;
866 -
867 - RRDSET *st_deadLocks;
868 - RRDDIM *rd_lockWait;
869 -
870 - RRDSET *st_lockWait;
871 - RRDDIM *rd_deadLocks;
872 -};
873 -
874 -struct mssql_db_jobs {
875 - bool enabled;
876 -
877 - RRDSET *st_status;
878 - RRDDIM *rd_status_enabled;
879 - RRDDIM *rd_status_disabled;
880 -
881 - COUNTER_DATA MSSQLJOBState;
882 -};
883 -
884 -struct mssql_db_instance {
885 - struct mssql_instance *parent;
886 -
887 - bool collecting_data;
888 - bool collect_instance;
889 - bool running_replication;
890 -
891 - RRDSET *st_db_data_file_size;
892 - RRDSET *st_db_active_transactions;
893 - RRDSET *st_db_backup_restore_operations;
894 - RRDSET *st_db_log_flushed;
895 - RRDSET *st_db_log_flushes;
896 - RRDSET *st_db_transactions;
897 - RRDSET *st_db_write_transactions;
898 - RRDSET *st_db_lockwait;
899 - RRDSET *st_db_deadlock;
900 - RRDSET *st_db_readonly;
901 - RRDSET *st_db_state;
902 - RRDSET *st_lock_timeouts;
903 - RRDSET *st_lock_requests;
904 - RRDSET *st_buff_page_iops;
905 - RRDSET *st_buff_cache_hits;
906 - RRDSET *st_buff_checkpoint_pages;
907 - RRDSET *st_buff_cache_page_life_expectancy;
908 - RRDSET *st_buff_lazy_write;
909 - RRDSET *st_buff_page_lookups;
910 -
911 - RRDSET *st_stats_compilation;
912 - RRDSET *st_stats_recompiles;
913 -
914 - RRDDIM *rd_db_data_file_size;
915 - RRDDIM *rd_db_active_transactions;
916 - RRDDIM *rd_db_backup_restore_operations;
917 - RRDDIM *rd_db_log_flushed;
918 - RRDDIM *rd_db_log_flushes;
919 - RRDDIM *rd_db_transactions;
920 - RRDDIM *rd_db_write_transactions;
921 - RRDDIM *rd_db_lockwait;
922 - RRDDIM *rd_db_deadlock;
923 - RRDDIM *rd_db_readonly_yes;
924 - RRDDIM *rd_db_readonly_no;
925 - RRDDIM *rd_db_state[NETDATA_DB_STATES];
926 - RRDDIM *rd_lock_timeouts;
927 - RRDDIM *rd_lock_requests;
928 - RRDDIM *rd_buff_page_reads;
929 - RRDDIM *rd_buff_page_writes;
930 - RRDDIM *rd_buff_cache_hits;
931 - RRDDIM *rd_buff_checkpoint_pages;
932 - RRDDIM *rd_buff_cache_page_life_expectancy;
933 - RRDDIM *rd_buff_lazy_write;
934 - RRDDIM *rd_buff_page_lookups;
935 -
936 - RRDDIM *rd_stats_compilation;
937 - RRDDIM *rd_stats_recompiles;
938 -
939 - COUNTER_DATA MSSQLDatabaseDataFileSize;
940 -
941 - COUNTER_DATA MSSQLDatabaseActiveTransactions;
942 - COUNTER_DATA MSSQLDatabaseBackupRestoreOperations;
943 - COUNTER_DATA MSSQLDatabaseLogFlushed;
944 - COUNTER_DATA MSSQLDatabaseLogFlushes;
945 - COUNTER_DATA MSSQLDatabaseTransactions;
946 - COUNTER_DATA MSSQLDatabaseWriteTransactions;
947 -
948 - COUNTER_DATA MSSQLDatabaseLockWaitSec;
949 - COUNTER_DATA MSSQLDatabaseDeadLockSec;
950 - COUNTER_DATA MSSQLDatabaseLockTimeoutsSec;
951 - COUNTER_DATA MSSQLDatabaseLockRequestsSec;
952 -
953 - // Buffer Management (https://learn.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-buffer-manager-object)
954 - COUNTER_DATA MSSQLBufferPageReads;
955 - COUNTER_DATA MSSQLBufferPageWrites;
956 - COUNTER_DATA MSSQLBufferCacheHits;
957 - COUNTER_DATA MSSQLBufferCheckpointPages;
958 - COUNTER_DATA MSSQLBufferPageLifeExpectancy;
959 - COUNTER_DATA MSSQLBufferLazyWrite;
960 - COUNTER_DATA MSSQLBufferPageLookups;
961 -
962 - COUNTER_DATA MSSQLCompilations;
963 - COUNTER_DATA MSSQLRecompilations;
964 -
965 - COUNTER_DATA MSSQLDBIsReadonly;
966 - COUNTER_DATA MSSQLDBState;
967 -
968 - uint32_t updated;
969 -};
970 -
971 -enum netdata_mssql_odbc_errors {
972 - NETDATA_MSSQL_ODBC_NO_ERROR,
973 - NETDATA_MSSQL_ODBC_CONNECT,
974 - NETDATA_MSSQL_ODBC_BIND,
975 - NETDATA_MSSQL_ODBC_PREPARE,
976 - NETDATA_MSSQL_ODBC_QUERY,
977 - NETDATA_MSSQL_ODBC_FETCH
978 -};
979 -
980 -static inline PERF_DATA_BLOCK *
981 -netdata_mssql_get_perf_data_block(bool *collect_perflib, struct mssql_instance *mi, DWORD idx)
982 -{
983 - DWORD id = RegistryFindIDByName(mi->objectName[idx]);
984 - if (id == PERFLIB_REGISTRY_NAME_NOT_FOUND) {
985 - collect_perflib[idx] = false;
986 - return NULL;
987 - }
988 -
989 - PERF_DATA_BLOCK *pDataBlock = perflibGetPerformanceData(id);
990 - if (!pDataBlock) {
991 - collect_perflib[idx] = true;
992 - return NULL;
993 - }
994 -
995 - return pDataBlock;
996 -}
997 -
998 -extern void do_mssql_general_stats(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every);
999 -extern void do_mssql_errors(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every);
1000 -extern void do_mssql_memory_mgr(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every);
1001 -extern void do_mssql_statistics_perflib(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every);
1002 -extern void do_mssql_access_methods(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every);
1003 -extern void do_mssql_user_connections(struct mssql_instance *mi, int update_every);
1004 -extern void do_mssql_sessions_connections(struct mssql_instance *mi, int update_every);
1005 -extern void netdata_mssql_blocked_processes_chart(struct mssql_instance *mi, int update_every);
1006 -#endif
src/collectors/windows.plugin/perflib-mssql.c deleted
-434
@@ -1,434 +0,0 @@
1 -// SPDX-License-Identifier: GPL-3.0-or-later
2 -
3 -#include "windows_plugin.h"
4 -#include "windows-internals.h"
5 -
6 -#include "perflib-mssql-queries.h"
7 -
8 -void do_mssql_access_methods(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
9 -{
10 - char id[RRD_ID_LENGTH_MAX + 1];
11 -
12 - PERF_OBJECT_TYPE *pObjectType =
13 - perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_ACCESS_METHODS]);
14 - if (unlikely(!pObjectType))
15 - return;
16 -
17 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLAccessMethodPageSplits))) {
18 - if (unlikely(!mi->st_access_method_page_splits)) {
19 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_accessmethods_page_splits", mi->instanceID);
20 - netdata_fix_chart_name(id);
21 - mi->st_access_method_page_splits = rrdset_create_localhost(
22 - "mssql",
23 - id,
24 - NULL,
25 - "buffer cache",
26 - "mssql.instance_accessmethods_page_splits",
27 - "Page splits",
28 - "splits/s",
29 - PLUGIN_WINDOWS_NAME,
30 - "PerflibMSSQL",
31 - PRIO_MSSQL_BUFF_METHODS_PAGE_SPLIT,
32 - update_every,
33 - RRDSET_TYPE_LINE);
34 -
35 - mi->rd_access_method_page_splits =
36 - rrddim_add(mi->st_access_method_page_splits, "page", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
37 -
38 - rrdlabels_add(
39 - mi->st_access_method_page_splits->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
40 - }
41 -
42 - rrddim_set_by_pointer(
43 - mi->st_access_method_page_splits,
44 - mi->rd_access_method_page_splits,
45 - (collected_number)mi->MSSQLAccessMethodPageSplits.current.Data);
46 - rrdset_done(mi->st_access_method_page_splits);
47 - }
48 -}
49 -
50 -void do_mssql_auto_parameterization_attempts(struct mssql_instance *mi, int update_every)
51 -{
52 - if (unlikely(!mi->st_stats_auto_param)) {
53 - char id[RRD_ID_LENGTH_MAX + 1];
54 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_sqlstats_auto_parameterization_attempts", mi->instanceID);
55 - netdata_fix_chart_name(id);
56 - mi->st_stats_auto_param = rrdset_create_localhost(
57 - "mssql",
58 - id,
59 - NULL,
60 - "sql activity",
61 - "mssql.instance_sqlstats_auto_parameterization_attempts",
62 - "Failed auto-parameterization attempts",
63 - "attempts/s",
64 - PLUGIN_WINDOWS_NAME,
65 - "PerflibMSSQL",
66 - PRIO_MSSQL_STATS_AUTO_PARAMETRIZATION,
67 - update_every,
68 - RRDSET_TYPE_LINE);
69 -
70 - mi->rd_stats_auto_param =
71 - rrddim_add(mi->st_stats_auto_param, "failed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
72 -
73 - rrdlabels_add(mi->st_stats_auto_param->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
74 - }
75 -
76 - rrddim_set_by_pointer(
77 - mi->st_stats_auto_param,
78 - mi->rd_stats_auto_param,
79 - (collected_number)mi->MSSQLStatsAutoParameterization.current.Data);
80 - rrdset_done(mi->st_stats_auto_param);
81 -}
82 -
83 -void do_mssql_batch_requests(struct mssql_instance *mi, int update_every)
84 -{
85 - if (unlikely(!mi->st_stats_batch_request)) {
86 - char id[RRD_ID_LENGTH_MAX + 1];
87 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_sqlstats_batch_requests", mi->instanceID);
88 - netdata_fix_chart_name(id);
89 - mi->st_stats_batch_request = rrdset_create_localhost(
90 - "mssql",
91 - id,
92 - NULL,
93 - "sql activity",
94 - "mssql.instance_sqlstats_batch_requests",
95 - "Total of batches requests",
96 - "requests/s",
97 - PLUGIN_WINDOWS_NAME,
98 - "PerflibMSSQL",
99 - PRIO_MSSQL_STATS_BATCH_REQUEST,
100 - update_every,
101 - RRDSET_TYPE_LINE);
102 -
103 - mi->rd_stats_batch_request =
104 - rrddim_add(mi->st_stats_batch_request, "batch", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
105 -
106 - rrdlabels_add(mi->st_stats_batch_request->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
107 - }
108 -
109 - rrddim_set_by_pointer(
110 - mi->st_stats_batch_request,
111 - mi->rd_stats_batch_request,
112 - (collected_number)mi->MSSQLStatsBatchRequests.current.Data);
113 - rrdset_done(mi->st_stats_batch_request);
114 -}
115 -
116 -void do_mssql_safe_auto_parameterization_attempts(struct mssql_instance *mi, int update_every)
117 -{
118 - if (unlikely(!mi->st_stats_safe_auto)) {
119 - char id[RRD_ID_LENGTH_MAX + 1];
120 - snprintfz(
121 - id, RRD_ID_LENGTH_MAX, "instance_%s_sqlstats_safe_auto_parameterization_attempts", mi->instanceID);
122 - netdata_fix_chart_name(id);
123 - mi->st_stats_safe_auto = rrdset_create_localhost(
124 - "mssql",
125 - id,
126 - NULL,
127 - "sql activity",
128 - "mssql.instance_sqlstats_safe_auto_parameterization_attempts",
129 - "Safe auto-parameterization attempts",
130 - "attempts/s",
131 - PLUGIN_WINDOWS_NAME,
132 - "PerflibMSSQL",
133 - PRIO_MSSQL_STATS_SAFE_AUTO_PARAMETRIZATION,
134 - update_every,
135 - RRDSET_TYPE_LINE);
136 -
137 - mi->rd_stats_safe_auto = rrddim_add(mi->st_stats_safe_auto, "safe", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
138 -
139 - rrdlabels_add(mi->st_stats_safe_auto->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
140 - }
141 -
142 - rrddim_set_by_pointer(
143 - mi->st_stats_safe_auto,
144 - mi->rd_stats_safe_auto,
145 - (collected_number)mi->MSSQLStatSafeAutoParameterization.current.Data);
146 - rrdset_done(mi->st_stats_safe_auto);
147 -}
148 -
149 -void do_mssql_statistics_perflib(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
150 -{
151 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_SQL_STATS]);
152 - if (unlikely(!pObjectType))
153 - return;
154 -
155 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLStatsAutoParameterization)))
156 - do_mssql_auto_parameterization_attempts(mi, update_every);
157 -
158 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLStatsBatchRequests)))
159 - do_mssql_batch_requests(mi, update_every);
160 -
161 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLStatSafeAutoParameterization)))
162 - do_mssql_safe_auto_parameterization_attempts(mi, update_every);
163 -}
164 -
165 -void do_mssql_memmgr_connection_memory_bytes(struct mssql_instance *mi, int update_every)
166 -{
167 - if (unlikely(!mi->st_conn_memory)) {
168 - char id[RRD_ID_LENGTH_MAX + 1];
169 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_memmgr_connection_memory_bytes", mi->instanceID);
170 - netdata_fix_chart_name(id);
171 - mi->st_conn_memory = rrdset_create_localhost(
172 - "mssql",
173 - id,
174 - NULL,
175 - "memory",
176 - "mssql.instance_memmgr_connection_memory_bytes",
177 - "Amount of dynamic memory to maintain connections",
178 - "bytes",
179 - PLUGIN_WINDOWS_NAME,
180 - "PerflibMSSQL",
181 - PRIO_MSSQL_MEMMGR_CONNECTION_MEMORY_BYTES,
182 - update_every,
183 - RRDSET_TYPE_LINE);
184 -
185 - mi->rd_conn_memory = rrddim_add(mi->st_conn_memory, "memory", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
186 -
187 - rrdlabels_add(mi->st_conn_memory->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
188 - }
189 -
190 - rrddim_set_by_pointer(
191 - mi->st_conn_memory,
192 - mi->rd_conn_memory,
193 - (collected_number)(mi->MSSQLConnectionMemoryBytes.current.Data * 1024));
194 - rrdset_done(mi->st_conn_memory);
195 -}
196 -
197 -void do_mssql_memmgr_external_benefit_of_memory(struct mssql_instance *mi, int update_every)
198 -{
199 - if (unlikely(!mi->st_ext_benefit_mem)) {
200 - char id[RRD_ID_LENGTH_MAX + 1];
201 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_memmgr_external_benefit_of_memory", mi->instanceID);
202 - netdata_fix_chart_name(id);
203 - mi->st_ext_benefit_mem = rrdset_create_localhost(
204 - "mssql",
205 - id,
206 - NULL,
207 - "memory",
208 - "mssql.instance_memmgr_external_benefit_of_memory",
209 - "Performance benefit from adding memory to a specific cache",
210 - "bytes",
211 - PLUGIN_WINDOWS_NAME,
212 - "PerflibMSSQL",
213 - PRIO_MSSQL_MEMMGR_EXTERNAL_BENEFIT_OF_MEMORY,
214 - update_every,
215 - RRDSET_TYPE_LINE);
216 -
217 - mi->rd_ext_benefit_mem = rrddim_add(mi->st_ext_benefit_mem, "benefit", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
218 -
219 - rrdlabels_add(mi->st_ext_benefit_mem->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
220 - }
221 -
222 - rrddim_set_by_pointer(
223 - mi->st_ext_benefit_mem,
224 - mi->rd_ext_benefit_mem,
225 - (collected_number)mi->MSSQLExternalBenefitOfMemory.current.Data);
226 - rrdset_done(mi->st_ext_benefit_mem);
227 -}
228 -
229 -void do_mssql_memmgr_pending_memory_grants(struct mssql_instance *mi, int update_every)
230 -{
231 - if (unlikely(!mi->st_pending_mem_grant)) {
232 - char id[RRD_ID_LENGTH_MAX + 1];
233 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_memmgr_pending_memory_grants", mi->instanceID);
234 - netdata_fix_chart_name(id);
235 - mi->st_pending_mem_grant = rrdset_create_localhost(
236 - "mssql",
237 - id,
238 - NULL,
239 - "memory",
240 - "mssql.instance_memmgr_pending_memory_grants",
241 - "Process waiting for memory grant",
242 - "processes",
243 - PLUGIN_WINDOWS_NAME,
244 - "PerflibMSSQL",
245 - PRIO_MSSQL_MEMMGR_PENDING_MEMORY_GRANTS,
246 - update_every,
247 - RRDSET_TYPE_LINE);
248 -
249 - mi->rd_pending_mem_grant =
250 - rrddim_add(mi->st_pending_mem_grant, "pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
251 -
252 - rrdlabels_add(mi->st_pending_mem_grant->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
253 - }
254 -
255 - rrddim_set_by_pointer(
256 - mi->st_pending_mem_grant,
257 - mi->rd_pending_mem_grant,
258 - (collected_number)mi->MSSQLPendingMemoryGrants.current.Data);
259 -
260 - rrdset_done(mi->st_pending_mem_grant);
261 -}
262 -
263 -void do_mssql_memmgr_memmgr_server_memory(struct mssql_instance *mi, int update_every)
264 -{
265 - if (unlikely(!mi->st_mem_tot_server)) {
266 - char id[RRD_ID_LENGTH_MAX + 1];
267 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_memmgr_server_memory", mi->instanceID);
268 - netdata_fix_chart_name(id);
269 - mi->st_mem_tot_server = rrdset_create_localhost(
270 - "mssql",
271 - id,
272 - NULL,
273 - "memory",
274 - "mssql.instance_memmgr_server_memory",
275 - "Memory committed",
276 - "bytes",
277 - PLUGIN_WINDOWS_NAME,
278 - "PerflibMSSQL",
279 - PRIO_MSSQL_MEMMGR_TOTAL_SERVER,
280 - update_every,
281 - RRDSET_TYPE_LINE);
282 -
283 - mi->rd_mem_tot_server = rrddim_add(mi->st_mem_tot_server, "memory", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
284 -
285 - rrdlabels_add(mi->st_mem_tot_server->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
286 - }
287 -
288 - rrddim_set_by_pointer(
289 - mi->st_mem_tot_server,
290 - mi->rd_mem_tot_server,
291 - (collected_number)(mi->MSSQLTotalServerMemory.current.Data * 1024));
292 -
293 - rrdset_done(mi->st_mem_tot_server);
294 -}
295 -
296 -void do_mssql_memory_mgr(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
297 -{
298 - char id[RRD_ID_LENGTH_MAX + 1];
299 -
300 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_MEMORY]);
301 - if (unlikely(!pObjectType))
302 - return;
303 -
304 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLConnectionMemoryBytes)))
305 - do_mssql_memmgr_connection_memory_bytes(mi, update_every);
306 -
307 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLExternalBenefitOfMemory))) {
308 - do_mssql_memmgr_external_benefit_of_memory(mi, update_every);
309 - }
310 -
311 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLPendingMemoryGrants))) {
312 - do_mssql_memmgr_pending_memory_grants(mi, update_every);
313 - }
314 -
315 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLTotalServerMemory))) {
316 - do_mssql_memmgr_memmgr_server_memory(mi, update_every);
317 - }
318 -}
319 -
320 -void do_mssql_errors(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
321 -{
322 - PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_SQL_ERRORS]);
323 - if (unlikely(!pObjectType))
324 - return;
325 -
326 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLSQLErrorsTotal))) {
327 - if (unlikely(!mi->st_sql_errors)) {
328 - char id[RRD_ID_LENGTH_MAX + 1];
329 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_sql_errors_total", mi->instanceID);
330 - netdata_fix_chart_name(id);
331 - mi->st_sql_errors = rrdset_create_localhost(
332 - "mssql",
333 - id,
334 - NULL,
335 - "errors",
336 - "mssql.instance_sql_errors",
337 - "Errors",
338 - "errors/s",
339 - PLUGIN_WINDOWS_NAME,
340 - "PerflibMSSQL",
341 - PRIO_MSSQL_SQL_ERRORS,
342 - update_every,
343 - RRDSET_TYPE_LINE);
344 -
345 - mi->rd_sql_errors = rrddim_add(mi->st_sql_errors, "errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
346 -
347 - rrdlabels_add(mi->st_sql_errors->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
348 - }
349 -
350 - rrddim_set_by_pointer(
351 - mi->st_sql_errors, mi->rd_sql_errors, (collected_number)mi->MSSQLSQLErrorsTotal.current.Data);
352 - rrdset_done(mi->st_sql_errors);
353 - }
354 -}
355 -
356 -void do_mssql_user_connections(struct mssql_instance *mi, int update_every)
357 -{
358 - if (unlikely(!mi->st_user_connections)) {
359 - char id[RRD_ID_LENGTH_MAX + 1];
360 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_user_connections", mi->instanceID);
361 - netdata_fix_chart_name(id);
362 - mi->st_user_connections = rrdset_create_localhost(
363 - "mssql",
364 - id,
365 - NULL,
366 - "connections",
367 - "mssql.instance_user_connections",
368 - "User connections",
369 - "connections",
370 - PLUGIN_WINDOWS_NAME,
371 - "PerflibMSSQL",
372 - PRIO_MSSQL_USER_CONNECTIONS,
373 - update_every,
374 - RRDSET_TYPE_LINE);
375 -
376 - mi->rd_user_connections = rrddim_add(mi->st_user_connections, "user", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
377 -
378 - rrdlabels_add(mi->st_user_connections->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
379 - }
380 -
381 - rrddim_set_by_pointer(
382 - mi->st_user_connections, mi->rd_user_connections, (collected_number)mi->MSSQLUserConnections.current.Data);
383 - rrdset_done(mi->st_user_connections);
384 -}
385 -
386 -void do_mssql_sessions_connections(struct mssql_instance *mi, int update_every)
387 -{
388 - if (unlikely(!mi->st_session_connections)) {
389 - char id[RRD_ID_LENGTH_MAX + 1];
390 - snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_sessions_connections", mi->instanceID);
391 - netdata_fix_chart_name(id);
392 - mi->st_session_connections = rrdset_create_localhost(
393 - "mssql",
394 - id,
395 - NULL,
396 - "connections",
397 - "mssql.instance_sessions_connections",
398 - "Session connections",
399 - "connections",
400 - PLUGIN_WINDOWS_NAME,
401 - "PerflibMSSQL",
402 - PRIO_MSSQL_SESSIONS_CONNECTIONS,
403 - update_every,
404 - RRDSET_TYPE_LINE);
405 -
406 - mi->rd_session_connections = rrddim_add(mi->st_session_connections, "session", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
407 -
408 - rrdlabels_add(mi->st_session_connections->rrdlabels, "mssql_instance", mi->instanceID, RRDLABEL_SRC_AUTO);
409 - }
410 -
411 - rrddim_set_by_pointer(
412 - mi->st_session_connections,
413 - mi->rd_session_connections,
414 - (collected_number)mi->MSSQLSessionConnections.current.Data);
415 - rrdset_done(mi->st_session_connections);
416 -}
417 -
418 -void do_mssql_general_stats(PERF_DATA_BLOCK *pDataBlock, struct mssql_instance *mi, int update_every)
419 -{
420 - PERF_OBJECT_TYPE *pObjectType =
421 - perflibFindObjectTypeByName(pDataBlock, mi->objectName[NETDATA_MSSQL_GENERAL_STATS]);
422 - if (unlikely(!pObjectType))
423 - return;
424 -
425 - if (unlikely(!mi->conn || !mi->conn->collect_user_connections)) {
426 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLUserConnections)))
427 - do_mssql_user_connections(mi, update_every);
428 - }
429 -
430 - if (unlikely(!mi->conn || !mi->conn->collect_blocked_processes)) {
431 - if (likely(perflibGetObjectCounter(pDataBlock, pObjectType, &mi->MSSQLBlockedProcesses)))
432 - netdata_mssql_blocked_processes_chart(mi, update_every);
433 - }
434 -}
src/collectors/windows.plugin/windows_plugin.c
-8
@@ -141,14 +141,6 @@ static struct proc_module {
141 .rd = NULL,
142 .thread = NULL,
143 .cleanup = NULL},
144 - {.name = "PerflibMSSQL",
145 - .dim = "PerflibMSSQL",
146 - .enabled = CONFIG_BOOLEAN_YES,
147 - .update_every = 10 * UPDATE_EVERY_MIN,
148 - .func = do_PerflibMSSQL,
149 - .rd = NULL,
150 - .thread = NULL,
151 - .cleanup = do_PerflibMSSQL_cleanup},
144 {.name = "PerflibNetFramework",
145 .dim = "PerflibNetFramework",
146 .enabled = CONFIG_BOOLEAN_YES,
src/collectors/windows.plugin/windows_plugin.h
-72
@@ -41,7 +41,6 @@ int do_PerflibMemory(int update_every, usec_t dt);
41 int do_PerflibObjects(int update_every, usec_t dt);
42 int do_PerflibThermalZone(int update_every, usec_t dt);
43 int do_PerflibWebService(int update_every, usec_t dt);
44 -int do_PerflibMSSQL(int update_every, usec_t dt);
44 int do_PerflibNetFramework(int update_every, usec_t dt);
45 int do_PerflibAD(int update_every, usec_t dt);
46 int do_PerflibADCS(int update_every, usec_t dt);
@@ -52,22 +51,11 @@ int do_PerflibNUMA(int update_every, usec_t dt __maybe_unused);
51 int do_PerflibASP(int update_every, usec_t dt __maybe_unused);
52
53 // Cleanup
55 -void do_PerflibMSSQL_cleanup();
54 void do_GetHardwareInfo_cleanup();
55 void do_Sensors_cleanup();
56 void do_GetServicesStatus_cleanup();
57 void do_GetSystemCPU_cleanup();
58
61 -enum MSSQL_REPLICATION_WARNINGS {
62 - MSSQL_REPLICATON_EXPIRATION = 1 << 0,
63 - MSSQL_REPLICATON_LATENCY = 1 << 1,
64 - MSSQL_REPLICATON_MERGEEXPIRATION = 1 << 2,
65 - MSSQL_REPLICATON_MERGEFASTDURATION = 1 << 3,
66 - MSSQL_REPLICATON_MERGELOWDURATION = 1 << 4,
67 - MSSQL_REPLICATON_MERGEFASTRUNSPEED = 1 << 5,
68 - MSSQL_REPLICATON_MERGELOWRUNSPEED = 1 << 6
69 -};
70 -
59 enum PERFLIB_PRIO {
60 PRIO_WEBSITE_IIS_REQUESTS_RATE = 21000, // PRIO selected, because APPS is using 20YYY
61 PRIO_WEBSITE_IIS_REQUESTS_BY_TYPE_RATE,
@@ -108,66 +96,6 @@ enum PERFLIB_PRIO {
96 PRIO_W3SVC_W3WP_OUTPUT_CACHE_MEMORY_USAGE,
97 PRIO_W3SVC_W3WP_OUTPUT_CACHE_FLUSHED_TOTAL,
98
111 - PRIO_MSSQL_USER_CONNECTIONS,
112 - PRIO_MSSQL_SESSIONS_CONNECTIONS,
113 -
114 - PRIO_MSSQL_DATABASE_TRANSACTIONS,
115 - PRIO_MSSQL_DATABASE_ACTIVE_TRANSACTIONS,
116 - PRIO_MSSQL_DATABASE_WRITE_TRANSACTIONS,
117 - PRIO_MSSQL_DATABASE_BACKUP_RESTORE_OPERATIONS,
118 - PRIO_MSSQL_DATABASE_LOG_FLUSHES,
119 - PRIO_MSSQL_DATABASE_LOG_FLUSHED,
120 -
121 - PRIO_MSSQL_DATABASE_LOCKWAIT_PER_SECOND,
122 - PRIO_MSSQL_DATABASE_DEADLOCKS_PER_SECOND,
123 - PRIO_MSSQL_DATABASE_LOCKS_TIMEOUT_PER_SECOND,
124 - PRIO_MSSQL_DATABASE_LOCK_REQUESTS_SEC,
125 -
126 - PRIO_MSSQL_DATABASE_READONLY,
127 - PRIO_MSSQL_DATABASE_STATE,
128 - PRIO_MSSQL_DATABASE_JOBS_STATUS,
129 -
130 - PRIO_MSSQL_DATABASE_DATA_FILE_SIZE,
131 -
132 - PRIO_MSSQL_STATS_BATCH_REQUEST,
133 - PRIO_MSSQL_STATS_COMPILATIONS,
134 - PRIO_MSSQL_STATS_RECOMPILATIONS,
135 - PRIO_MSSQL_STATS_AUTO_PARAMETRIZATION,
136 - PRIO_MSSQL_STATS_SAFE_AUTO_PARAMETRIZATION,
137 -
138 - PRIO_MSSQL_BLOCKED_PROCESSES,
139 -
140 - PRIO_MSSQL_BUFF_CACHE_HIT_RATIO,
141 - PRIO_MSSQL_BUFF_MAN_IOPS,
142 - PRIO_MSSQL_BUFF_CHECKPOINT_PAGES,
143 - PRIO_MSSQL_BUFF_METHODS_PAGE_SPLIT,
144 - PRIO_MSSQL_BUFF_PAGE_LIFE_EXPECTANCY,
145 - PRIO_MSSQL_BUFF_LAZY_WRITE,
146 - PRIO_MSSQL_BUFF_PAGE_LOOKUPS,
147 -
148 - PRIO_MSSQL_MEMMGR_CONNECTION_MEMORY_BYTES,
149 - PRIO_MSSQL_MEMMGR_TOTAL_SERVER,
150 - PRIO_MSSQL_MEMMGR_EXTERNAL_BENEFIT_OF_MEMORY,
151 - PRIO_MSSQL_MEMMGR_PENDING_MEMORY_GRANTS,
152 -
153 - PRIO_MSSQL_LOCKS_WAIT,
154 - PRIO_MSSQL_LOCKS_DEADLOCK_PER_RESOURCE,
155 -
156 - PRIO_MSSQL_WAITS_TOTAL,
157 - PRIO_MSSQL_RESOURCE_WAIT,
158 - PRIO_MSSQL_SIGNAL_WAIT,
159 - PRIO_MSSQL_MAX_WAIT_TIME,
160 - PRIO_MSSQL_WAITING_COUNT,
161 -
162 - PRIO_MSSQL_SQL_ERRORS,
163 -
164 - PRIO_MSSQL_REPLICATION_STATUS,
165 - PRIO_MSSQL_REPLICATION_WARNING,
166 - PRIO_MSSQL_REPLICATION_AVG_LATENCY,
167 - PRIO_MSSQL_REPLICATION_SUBSCRIPTION_COUNT,
168 - PRIO_MSSQL_REPLICATION_AGENT_RUNNING,
169 - PRIO_MSSQL_REPLICATION_SYNC_TIME,
170 -
99 PRIO_NETFRAMEWORK_CLR_EXCEPTION_THROWN,
100 PRIO_NETFRAMEWORK_CLR_EXCEPTION_FILTERS,
101 PRIO_NETFRAMEWORK_CLR_EXCEPTION_FINALLYS,