@cryptotaxi247 / netdata-1 / commits / c97bc7edf

Merge MSSQL Queries (windows.plugin) (#21491)

thiagoftsm committed Jan 8, 2026 at 15:19 UTC c97bc7edf7e7a3dcf1db873041e7eea335deca73

2 files changed +183 -209

src/collectors/windows.plugin/MonitorSQL.c

+180 -203

@@ -122,117 +122,6 @@ static ULONGLONG netdata_MSSQL_fill_long_value(SQLHSTMT stmt, const char *mask,

122 #define NETDATA_MSSQL_STATS_COMPILATIONS_METRIC "SQL Compilations/sec"

123 #define NETDATA_MSSQL_STATS_RECOMPILATIONS_METRIC "SQL Re-Compilations/sec"

124

125 -void dict_mssql_fill_instance_transactions(struct mssql_db_instance *mdi)

126 -{

127 - if (unlikely(!mdi || !mdi->parent || !mdi->parent->conn || !mdi->parent->conn->collect_buffer))

128 - return;

129 -

130 - char object_name[NETDATA_MAX_INSTANCE_OBJECT + 1] = {};

131 - long value = 0;

132 - SQLLEN col_object_len = 0, col_value_len = 0;

133 -

134 - SQLRETURN ret =

135 - SQLExecDirect(mdi->parent->conn->dbInstanceTransactionSTMT, (SQLCHAR *)NETDATA_QUERY_BUFFER_STATS, SQL_NTS);

136 - if (likely(netdata_mssql_check_result(ret))) {

137 - mdi->collecting_data = false;

138 - netdata_MSSQL_error(

139 - SQL_HANDLE_STMT,

140 - mdi->parent->conn->dbInstanceTransactionSTMT,

141 - NETDATA_MSSQL_ODBC_QUERY,

142 - mdi->parent->instanceID);

143 - goto enditransactions;

144 - }

145 -

146 - ret = SQLBindCol(

147 - mdi->parent->conn->dbInstanceTransactionSTMT, 1, SQL_C_CHAR, object_name, sizeof(object_name), &col_object_len);

148 - if (likely(netdata_mssql_check_result(ret))) {

149 - netdata_MSSQL_error(

150 - SQL_HANDLE_STMT,

151 - mdi->parent->conn->dbInstanceTransactionSTMT,

152 - NETDATA_MSSQL_ODBC_PREPARE,

153 - mdi->parent->instanceID);

154 - goto enditransactions;

155 - }

156 -

157 - ret =

158 - SQLBindCol(mdi->parent->conn->dbInstanceTransactionSTMT, 2, SQL_C_LONG, &value, sizeof(value), &col_value_len);

159 - if (likely(netdata_mssql_check_result(ret))) {

160 - netdata_MSSQL_error(

161 - SQL_HANDLE_STMT,

162 - mdi->parent->conn->dbInstanceTransactionSTMT,

163 - NETDATA_MSSQL_ODBC_PREPARE,

164 - mdi->parent->instanceID);

165 - goto enditransactions;

166 - }

167 -

168 - do {

169 - ret = SQLFetch(mdi->parent->conn->dbInstanceTransactionSTMT);

170 - switch (ret) {

171 - case SQL_SUCCESS:

172 - case SQL_SUCCESS_WITH_INFO:

173 - break;

174 - case SQL_NO_DATA:

175 - default:

176 - goto enditransactions;

177 - }

178 -

179 - if (col_object_len == SQL_NULL_DATA)

180 - object_name[0] = '\0';

181 - if (col_value_len == SQL_NULL_DATA)

182 - value = 0;

183 -

184 - // We cannot use strcmp, because buffer is filled with spaces instead NULL.

185 - if (unlikely(!strncmp(

186 - object_name,

187 - NETDATA_MSSQL_BUFFER_PAGE_READS_METRIC,

188 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_READS_METRIC) - 1)))

189 - mdi->MSSQLBufferPageReads.current.Data = (ULONGLONG)value;

190 - else if (unlikely(!strncmp(

191 - object_name,

192 - NETDATA_MSSQL_BUFFER_PAGE_WRITES_METRIC,

193 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_WRITES_METRIC) - 1)))

194 - mdi->MSSQLBufferPageWrites.current.Data = (ULONGLONG)value;

195 - else if (unlikely(!strncmp(

196 - object_name,

197 - NETDATA_MSSQL_BUFFER_PAGE_CACHE_METRIC,

198 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_CACHE_METRIC) - 1)))

199 - mdi->MSSQLBufferCacheHits.current.Data = (ULONGLONG)value;

200 - else if (unlikely(!strncmp(

201 - object_name,

202 - NETDATA_MSSQL_BUFFER_CHECKPOINT_METRIC,

203 - sizeof(NETDATA_MSSQL_BUFFER_CHECKPOINT_METRIC) - 1)))

204 - mdi->MSSQLBufferCheckpointPages.current.Data = (ULONGLONG)value;

205 - else if (unlikely(!strncmp(

206 - object_name,

207 - NETDATA_MSSQL_BUFFER_PAGE_LIFE_METRIC,

208 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_LIFE_METRIC) - 1)))

209 - mdi->MSSQLBufferPageLifeExpectancy.current.Data = (ULONGLONG)value;

210 - else if (unlikely(!strncmp(

211 - object_name,

212 - NETDATA_MSSQL_BUFFER_LAZY_WRITES_METRIC,

213 - sizeof(NETDATA_MSSQL_BUFFER_LAZY_WRITES_METRIC) - 1)))

214 - mdi->MSSQLBufferLazyWrite.current.Data = (ULONGLONG)value;

215 - else if (unlikely(!strncmp(

216 - object_name,

217 - NETDATA_MSSQL_BUFFER_PAGE_LOOKUPS_METRIC,

218 - sizeof(NETDATA_MSSQL_BUFFER_PAGE_LOOKUPS_METRIC) - 1)))

219 - mdi->MSSQLBufferPageLookups.current.Data = (ULONGLONG)value;

220 - else if (unlikely(!strncmp(

221 - object_name,

222 - NETDATA_MSSQL_STATS_COMPILATIONS_METRIC,

223 - sizeof(NETDATA_MSSQL_STATS_COMPILATIONS_METRIC) - 1)))

224 - mdi->MSSQLCompilations.current.Data = (ULONGLONG)value;

225 - else if (unlikely(!strncmp(

226 - object_name,

227 - NETDATA_MSSQL_STATS_RECOMPILATIONS_METRIC,

228 - sizeof(NETDATA_MSSQL_STATS_RECOMPILATIONS_METRIC) - 1)))

229 - mdi->MSSQLRecompilations.current.Data = (ULONGLONG)value;

230 - } while (true);

231 -

232 -enditransactions:

233 - netdata_MSSQL_release_results(mdi->parent->conn->dbInstanceTransactionSTMT);

234 -}

235 -

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"

@@ -244,58 +133,180 @@ enditransactions:

133 #define NETDATA_MSSQL_LOCK_TIMEOUTS_METRIC "Lock Timeouts/sec"

134 #define NETDATA_MSSQL_LOCK_REQUESTS_METRIC "Lock Requests/sec"

135

247 -void dict_mssql_fill_transactions(struct mssql_db_instance *mdi, const char *dbname)

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

253 - if (unlikely(!mdi->parent->conn->collect_transactions))

254 - goto endtransactions;

255 -

256 - if (likely(mdi->collect_instance))

257 - dict_mssql_fill_instance_transactions(mdi);

264 + if (unlikely(

265 + !mdi->parent->conn->collect_transactions && !mdi->parent->conn->collect_buffer && !mdi->collect_instance))

266 + return;

267

259 - SQLCHAR query[sizeof(NETDATA_QUERY_TRANSACTIONS_MASK) + 2 * NETDATA_MAX_INSTANCE_OBJECT + 1];

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,

262 - sizeof(NETDATA_QUERY_TRANSACTIONS_MASK) + 2 * NETDATA_MAX_INSTANCE_OBJECT,

263 - NETDATA_QUERY_TRANSACTIONS_MASK,

273 + sizeof(NETDATA_QUERY_PERFORMANCE_COUNTER) + 2 * NETDATA_MAX_INSTANCE_OBJECT,

274 + NETDATA_QUERY_PERFORMANCE_COUNTER,

275 dbname,

276 dbname);

277

267 - SQLRETURN ret = SQLExecDirect(mdi->parent->conn->dbTransactionSTMT, (SQLCHAR *)query, SQL_NTS);

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(

271 - SQL_HANDLE_STMT, mdi->parent->conn->dbTransactionSTMT, NETDATA_MSSQL_ODBC_QUERY, mdi->parent->instanceID);

272 - goto endtransactions;

282 + SQL_HANDLE_STMT, mdi->parent->conn->dbPerfCounterSTMT, NETDATA_MSSQL_ODBC_QUERY, mdi->parent->instanceID);

283 + goto endcounters;

284 }

285

286 ret = SQLBindCol(

276 - mdi->parent->conn->dbTransactionSTMT, 1, SQL_C_CHAR, object_name, sizeof(object_name), &col_object_len);

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(

279 - SQL_HANDLE_STMT, mdi->parent->conn->dbTransactionSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);

280 - goto endtransactions;

290 + SQL_HANDLE_STMT, mdi->parent->conn->dbPerfCounterSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);

291 + goto endcounters;

292 }

293

283 - ret = SQLBindCol(mdi->parent->conn->dbTransactionSTMT, 2, SQL_C_LONG, &value, sizeof(value), &col_value_len);

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(

286 - SQL_HANDLE_STMT, mdi->parent->conn->dbTransactionSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);

287 - goto endtransactions;

297 + SQL_HANDLE_STMT, mdi->parent->conn->dbPerfCounterSTMT, NETDATA_MSSQL_ODBC_PREPARE, mdi->parent->instanceID);

298 + goto endcounters;

299 }

300

301 do {

291 - ret = SQLFetch(mdi->parent->conn->dbTransactionSTMT);

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:

298 - goto endtransactions;

309 + goto endcounters;

310 }

311

312 if (col_object_len == SQL_NULL_DATA)

@@ -303,50 +314,19 @@ void dict_mssql_fill_transactions(struct mssql_db_instance *mdi, const char *dbn

314 if (col_value_len == SQL_NULL_DATA)

315 value = 0;

316

306 - // We cannot use strcmp, because buffer is filled with spaces instead NULL.

307 - if (unlikely(!strncmp(

308 - object_name,

309 - NETDATA_MSSQL_ACTIVE_TRANSACTIONS_METRIC,

310 - sizeof(NETDATA_MSSQL_ACTIVE_TRANSACTIONS_METRIC) - 1)))

311 - mdi->MSSQLDatabaseActiveTransactions.current.Data = (ULONGLONG)value;

312 - else if (unlikely(!strncmp(

313 - object_name,

314 - NETDATA_MSSQL_TRANSACTION_PER_SEC_METRIC,

315 - sizeof(NETDATA_MSSQL_TRANSACTION_PER_SEC_METRIC) - 1)))

316 - mdi->MSSQLDatabaseTransactions.current.Data = (ULONGLONG)value;

317 - else if (unlikely(!strncmp(

318 - object_name,

319 - NETDATA_MSSQL_WRITE_TRANSACTIONS_METRIC,

320 - sizeof(NETDATA_MSSQL_WRITE_TRANSACTIONS_METRIC) - 1)))

321 - mdi->MSSQLDatabaseWriteTransactions.current.Data = (ULONGLONG)value;

322 - else if (unlikely(!strncmp(

323 - object_name, NETDATA_MSSQL_BACKUP_RESTORE_METRIC, sizeof(NETDATA_MSSQL_BACKUP_RESTORE_METRIC) - 1)))

324 - mdi->MSSQLDatabaseBackupRestoreOperations.current.Data = (ULONGLONG)value;

325 - else if (unlikely(!strncmp(

326 - object_name, NETDATA_MSSQL_LOG_FLUSHED_METRIC, sizeof(NETDATA_MSSQL_LOG_FLUSHED_METRIC) - 1)))

327 - mdi->MSSQLDatabaseLogFlushed.current.Data = (ULONGLONG)value;

328 - else if (unlikely(!strncmp(

329 - object_name, NETDATA_MSSQL_LOG_FLUSHES_METRIC, sizeof(NETDATA_MSSQL_LOG_FLUSHES_METRIC) - 1)))

330 - mdi->MSSQLDatabaseLogFlushes.current.Data = (ULONGLONG)value;

331 - else if (unlikely(!strncmp(

332 - object_name,

333 - NETDATA_MSSQL_NUMBER_DEADLOCKS_METRIC,

334 - sizeof(NETDATA_MSSQL_NUMBER_DEADLOCKS_METRIC) - 1)))

335 - mdi->MSSQLDatabaseDeadLockSec.current.Data = (ULONGLONG)value;

336 - else if (unlikely(!strncmp(

337 - object_name, NETDATA_MSSQL_LOCK_WAITS_METRIC, sizeof(NETDATA_MSSQL_LOCK_WAITS_METRIC) - 1)))

338 - mdi->MSSQLDatabaseLockWaitSec.current.Data = (ULONGLONG)value;

339 - else if (unlikely(!strncmp(

340 - object_name, NETDATA_MSSQL_LOCK_TIMEOUTS_METRIC, sizeof(NETDATA_MSSQL_LOCK_TIMEOUTS_METRIC) - 1)))

341 - mdi->MSSQLDatabaseLockTimeoutsSec.current.Data = (ULONGLONG)value;

342 - else if (unlikely(!strncmp(

343 - object_name, NETDATA_MSSQL_LOCK_REQUESTS_METRIC, sizeof(NETDATA_MSSQL_LOCK_REQUESTS_METRIC) - 1)))

344 - mdi->MSSQLDatabaseLockRequestsSec.current.Data = (ULONGLONG)value;

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

348 -endtransactions:

349 - netdata_MSSQL_release_results(mdi->parent->conn->dbTransactionSTMT);

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)

@@ -453,8 +433,8 @@ int dict_mssql_fill_waits(struct mssql_instance *mi)

433 goto endwait;

434 }

435

456 - ret =

457 - SQLBindCol(mi->conn->dbWaitsSTMT, 3, SQL_C_SBIGINT, &resource_wait, sizeof(resource_wait), &col_resource_wait_len);

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;

@@ -472,8 +452,8 @@ int dict_mssql_fill_waits(struct mssql_instance *mi)

452 goto endwait;

453 }

454

475 - ret =

476 - SQLBindCol(mi->conn->dbWaitsSTMT, 6, SQL_C_SBIGINT, &waiting_tasks, sizeof(waiting_tasks), &col_waiting_tasks_len);

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;

@@ -747,7 +727,7 @@ void dict_mssql_fill_replication(struct mssql_db_instance *mdi)

727 if (publisher_len == SQL_NULL_DATA)

728 publisher[0] = '\0';

729

750 - if(unlikely(!publisher_db[0] || !publication[0]))

730 + if (unlikely(!publisher_db[0] || !publication[0]))

731 continue;

732

733 snprintfz(key, sizeof(key) - 1, "%s:%s", publisher_db, publication);

@@ -783,6 +763,7 @@ 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;

@@ -802,7 +783,7 @@ int dict_mssql_databases_run_queries(const DICTIONARY_ITEM *item __maybe_unused,

783 goto enddrunquery;

784 }

785

805 - dict_mssql_fill_transactions(mdi, dbname);

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))

@@ -1046,14 +1027,10 @@ static void netdata_mssql_fill_blocked_processes_query(struct mssql_instance *mi

1027 }

1028

1029 ret = SQLBindCol(

1049 - mi->conn->dbSQLBlockedProcesses,

1050 - 1,

1051 - SQL_C_LONG,

1052 - &blocked_processes,

1053 - sizeof(blocked_processes),

1054 - &col_len);

1030 + mi->conn->dbSQLBlockedProcesses, 1, SQL_C_LONG, &blocked_processes, sizeof(blocked_processes), &col_len);

1031 if (likely(netdata_mssql_check_result(ret))) {

1056 - netdata_MSSQL_error(SQL_HANDLE_STMT, mi->conn->dbSQLBlockedProcesses, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);

1032 + netdata_MSSQL_error(

1033 + SQL_HANDLE_STMT, mi->conn->dbSQLBlockedProcesses, NETDATA_MSSQL_ODBC_PREPARE, mi->instanceID);

1034 goto end_blocked_processes;

1035 }

1036

@@ -1195,7 +1172,7 @@ static bool netdata_MSSQL_initialize_connection(struct netdata_mssql_conn *nmc)

1172 goto endMSSQLInitializationConnection;

1173 }

1174

1198 - ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbTransactionSTMT);

1175 + ret = SQLAllocHandle(SQL_HANDLE_STMT, nmc->netdataSQLHDBc, &nmc->dbPerfCounterSTMT);

1176 if (likely(netdata_mssql_check_result(ret))) {

1177 retConn = FALSE;

1178 goto endMSSQLInitializationConnection;

@@ -1477,8 +1454,8 @@ static void netdata_read_config_options()

1454 dbconn->collect_data_size = inicfg_get_boolean(&netdata_config, section_name, "collect database size", true);

1455 dbconn->collect_user_connections =

1456 inicfg_get_boolean(&netdata_config, section_name, "collect user connections", true);

1480 - dbconn->collect_blocked_processes = inicfg_get_boolean(

1481 - &netdata_config, section_name, "collect blocked processes", true);

1457 + dbconn->collect_blocked_processes =

1458 + inicfg_get_boolean(&netdata_config, section_name, "collect blocked processes", true);

1459 dbconn->is_connected = FALSE;

1460

1461 netdata_mount_mssql_connection_string(dbconn);

@@ -1527,7 +1504,6 @@ void dict_mssql_insert_cb(const DICTIONARY_ITEM *item __maybe_unused, void *valu

1504 mssql_fill_initial_instances(mi);

1505 }

1506

1530 -

1507 if (unlikely(!mi->databases)) {

1508 mi->databases = dictionary_create_advanced(

1509 DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct mssql_db_instance));

@@ -1701,18 +1677,18 @@ void netdata_mssql_blocked_processes_chart(struct mssql_instance *mi, int update

1677 snprintfz(id, RRD_ID_LENGTH_MAX, "instance_%s_blocked_process", mi->instanceID);

1678 netdata_fix_chart_name(id);

1679 mi->st_process_blocked = rrdset_create_localhost(

1704 - "mssql",

1705 - id,

1706 - NULL,

1707 - "processes",

1708 - "mssql.instance_blocked_processes",

1709 - "Blocked processes",

1710 - "process",

1711 - PLUGIN_WINDOWS_NAME,

1712 - "PerflibMSSQL",

1713 - PRIO_MSSQL_BLOCKED_PROCESSES,

1714 - update_every,

1715 - RRDSET_TYPE_LINE);

1680 + "mssql",

1681 + id,

1682 + NULL,

1683 + "processes",

1684 + "mssql.instance_blocked_processes",

1685 + "Blocked processes",

1686 + "process",

1687 + PLUGIN_WINDOWS_NAME,

1688 + "PerflibMSSQL",

1689 + PRIO_MSSQL_BLOCKED_PROCESSES,

1690 + update_every,

1691 + RRDSET_TYPE_LINE);

1692

1693 mi->rd_process_blocked = rrddim_add(mi->st_process_blocked, "blocked", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);

1694

@@ -1720,11 +1696,12 @@ void netdata_mssql_blocked_processes_chart(struct mssql_instance *mi, int update

1696 }

1697

1698 rrddim_set_by_pointer(

1723 - mi->st_process_blocked, mi->rd_process_blocked, (collected_number)mi->MSSQLBlockedProcesses.current.Data);

1699 + mi->st_process_blocked, mi->rd_process_blocked, (collected_number)mi->MSSQLBlockedProcesses.current.Data);

1700 rrdset_done(mi->st_process_blocked);

1701 }

1702

1727 -static void do_mssql_blocked_processes(PERF_DATA_BLOCK *pDataBlock __maybe_unused, struct mssql_instance *mi, int update_every)

1703 +static void

1704 +do_mssql_blocked_processes(PERF_DATA_BLOCK *pDataBlock __maybe_unused, struct mssql_instance *mi, int update_every)

1705 {

1706 if (unlikely(!mi || !mi->conn || !mi->conn->collect_blocked_processes))

1707 return;

src/collectors/windows.plugin/perflib-mssql-queries.h

+3 -6

@@ -23,11 +23,8 @@

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_TRANSACTIONS_MASK \

27 - "SELECT counter_name, cntr_value FROM %s.sys.dm_os_performance_counters WHERE 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');"

28 -

29 -#define NETDATA_QUERY_BUFFER_STATS \

30 - "SELECT counter_name, cntr_value FROM sys.dm_os_performance_counters WHERE (object_name like '%%Buffer Manager%%' or object_name like '%%SQL Statistics%%') AND counter_name IN ('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');"

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');"

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;"

@@ -669,7 +666,7 @@ struct netdata_mssql_conn {

666 SQLHSTMT checkPermSTMT;

667 SQLHSTMT databaseListSTMT;

668 SQLHSTMT dataFileSizeSTMT;

672 - SQLHSTMT dbTransactionSTMT;

669 + SQLHSTMT dbPerfCounterSTMT;

670 SQLHSTMT dbInstanceTransactionSTMT;

671 SQLHSTMT dbWaitsSTMT;

672 SQLHSTMT dbLocksSTMT;