Active Directory Certification Service (windows.plugin) (#19492)
Co-authored-by: ilyam8 <ilya@netdata.cloud>
thiagoftsm committed
Jan 31, 2025 at 15:34 UTC
30892d49e7da21b805c0fc82ddaee5223b4fe449
4 files changed
+781
-28
CMakeLists.txt
+1
@@ -1775,6 +1775,7 @@ set(WINDOWS_PLUGIN_FILES
1775
src/collectors/windows.plugin/GetSystemUptime.c
1776
src/collectors/windows.plugin/GetSystemRAM.c
1777
src/collectors/windows.plugin/GetSystemCPU.c
1778
+ src/collectors/windows.plugin/perflib-adcs.c
1779
src/collectors/windows.plugin/perflib-rrd.c
1780
src/collectors/windows.plugin/perflib-rrd.h
1781
src/collectors/windows.plugin/perflib-ad.c
src/collectors/windows.plugin/perflib-adcs.c
new
+721
@@ -0,0 +1,721 @@
1
+// SPDX-License-Identifier: GPL-3.0-or-later
2
+
3
+#include "windows_plugin.h"
4
+#include "windows-internals.h"
5
+
6
+struct adcs_certificate {
7
+ char *name;
8
+
9
+ RRDSET *st_adcs_requests_total;
10
+ RRDDIM *rd_adcs_requests_total;
11
+
12
+ RRDSET *st_adcs_failed_requests_total;
13
+ RRDDIM *rd_adcs_failed_requests_total;
14
+
15
+ RRDSET *st_adcs_issued_requests_total;
16
+ RRDDIM *rd_adcs_issued_requests_total;
17
+
18
+ RRDSET *st_adcs_pending_requests_total;
19
+ RRDDIM *rd_adcs_pending_requests_total;
20
+
21
+ RRDSET *st_adcs_request_processing_time_seconds;
22
+ RRDDIM *rd_adcs_request_processing_time_seconds;
23
+
24
+ RRDSET *st_adcs_retrievals_total;
25
+ RRDDIM *rd_adcs_retrievals_total;
26
+
27
+ RRDSET *st_adcs_retrievals_processing_time_seconds;
28
+ RRDDIM *rd_adcs_retrievals_processing_time_seconds;
29
+
30
+ RRDSET *st_adcs_request_cryptographic_signing_time_seconds;
31
+ RRDDIM *rd_adcs_request_cryptographic_signing_time_seconds;
32
+
33
+ RRDSET *st_adcs_request_policy_module_processing_time_seconds;
34
+ RRDDIM *rd_adcs_request_policy_module_processing_time_seconds;
35
+
36
+ RRDSET *st_adcs_challenge_responses_total;
37
+ RRDDIM *rd_adcs_challenge_responses_total;
38
+
39
+ RRDSET *st_adcs_challenge_response_processing_time_seconds;
40
+ RRDDIM *rd_adcs_challenge_response_processing_time_seconds;
41
+
42
+ RRDSET *st_adcs_signed_certificate_timestamp_lists_total;
43
+ RRDDIM *rd_adcs_signed_certificate_timestamp_lists_total;
44
+
45
+ RRDSET *st_adcs_signed_certificate_timestamp_list_processing_time_seconds;
46
+ RRDDIM *rd_adcs_signed_certificate_timestamp_list_processing_time_seconds;
47
+
48
+ COUNTER_DATA ADCSRequestsTotal;
49
+ COUNTER_DATA ADCSFailedRequestsTotal;
50
+ COUNTER_DATA ADCSIssuedRequestsTotal;
51
+ COUNTER_DATA ADCSPendingRequestsTotal;
52
+ COUNTER_DATA ADCSRequestProcessingTime;
53
+ COUNTER_DATA ADCSRetrievalsTotal;
54
+ COUNTER_DATA ADCSRetrievalsProcessingTime;
55
+ COUNTER_DATA ADCSRequestCryptoSigningTime;
56
+ COUNTER_DATA ADCSRequestPolicyModuleProcessingTime;
57
+ COUNTER_DATA ADCSChallengeResponseResponsesTotal;
58
+ COUNTER_DATA ADCSChallengeResponseProcessingTime;
59
+ COUNTER_DATA ADCSSignedCertTimestampListsTotal;
60
+ COUNTER_DATA ADCSSignedCertTimestampListProcessingTime;
61
+};
62
+
63
+static DICTIONARY *adcs_certificates = NULL;
64
+
65
+void dict_adcs_insert_certificate_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused)
66
+{
67
+ struct adcs_certificate *ptr = value;
68
+ const char *name = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
69
+
70
+ ptr->name = strdupz(name);
71
+
72
+ ptr->ADCSRequestsTotal.key = "Requests/sec";
73
+ ptr->ADCSFailedRequestsTotal.key = "Failed Requests/sec";
74
+ ptr->ADCSIssuedRequestsTotal.key = "Issued Requests/sec";
75
+ ptr->ADCSPendingRequestsTotal.key = "Pending Requests/sec";
76
+ ptr->ADCSRequestProcessingTime.key = "Request processing time (ms)";
77
+ ptr->ADCSRetrievalsTotal.key = "Retrievals/sec";
78
+ ptr->ADCSRetrievalsProcessingTime.key = "Retrieval processing time (ms)";
79
+ ptr->ADCSRequestCryptoSigningTime.key = "Request cryptographic signing time (ms)";
80
+ ptr->ADCSRequestPolicyModuleProcessingTime.key = "Request policy module processing time (ms)";
81
+ ptr->ADCSChallengeResponseResponsesTotal.key = "Challenge Responses/sec";
82
+ ptr->ADCSChallengeResponseProcessingTime.key = "Challenge Response processing time (ms)";
83
+ ptr->ADCSSignedCertTimestampListsTotal.key = "Signed Certificate Timestamp Lists/sec";
84
+ ptr->ADCSSignedCertTimestampListProcessingTime.key = "Signed Certificate Timestamp List processing time (ms)";
85
+}
86
+
87
+static void initialize(void)
88
+{
89
+ adcs_certificates = dictionary_create_advanced(
90
+ DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct adcs_certificate));
91
+
92
+ dictionary_register_insert_callback(adcs_certificates, dict_adcs_insert_certificate_cb, NULL);
93
+}
94
+
95
+static void netdata_adcs_requests(
96
+ struct adcs_certificate *ac,
97
+ PERF_DATA_BLOCK *pDataBlock,
98
+ PERF_OBJECT_TYPE *pObjectType,
99
+ int update_every)
100
+{
101
+ char id[RRD_ID_LENGTH_MAX + 1];
102
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSRequestsTotal)) {
103
+ return;
104
+ }
105
+
106
+ if (!ac->st_adcs_requests_total) {
107
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_requests", ac->name);
108
+ ac->st_adcs_requests_total = rrdset_create_localhost(
109
+ "adcs",
110
+ id,
111
+ NULL,
112
+ "requests",
113
+ "adcs.cert_requests",
114
+ "Certificate requests processed",
115
+ "requests/s",
116
+ PLUGIN_WINDOWS_NAME,
117
+ "PerflibADCS",
118
+ PRIO_ADCS_CERT_REQUESTS_TOTAL,
119
+ update_every,
120
+ RRDSET_TYPE_LINE);
121
+
122
+ ac->rd_adcs_requests_total =
123
+ rrddim_add(ac->st_adcs_requests_total, "requests", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
124
+
125
+ rrdlabels_add(ac->st_adcs_requests_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
126
+ }
127
+
128
+ rrddim_set_by_pointer(
129
+ ac->st_adcs_requests_total, ac->rd_adcs_requests_total, (collected_number)ac->ADCSRequestsTotal.current.Data);
130
+ rrdset_done(ac->st_adcs_requests_total);
131
+}
132
+
133
+static void netdata_adcs_requests_processing_time(
134
+ struct adcs_certificate *ac,
135
+ PERF_DATA_BLOCK *pDataBlock,
136
+ PERF_OBJECT_TYPE *pObjectType,
137
+ int update_every)
138
+{
139
+ char id[RRD_ID_LENGTH_MAX + 1];
140
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSRequestProcessingTime)) {
141
+ return;
142
+ }
143
+
144
+ if (!ac->st_adcs_request_processing_time_seconds) {
145
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_request_processing_time", ac->name);
146
+ ac->st_adcs_request_processing_time_seconds = rrdset_create_localhost(
147
+ "adcs",
148
+ id,
149
+ NULL,
150
+ "requests",
151
+ "adcs.cert_request_processing_time",
152
+ "Certificate last request processing time",
153
+ "seconds",
154
+ PLUGIN_WINDOWS_NAME,
155
+ "PerflibADCS",
156
+ PRIO_ADCS_CERT_REQUESTS_PROCESSING_TIME,
157
+ update_every,
158
+ RRDSET_TYPE_LINE);
159
+
160
+ ac->rd_adcs_request_processing_time_seconds = rrddim_add(
161
+ ac->st_adcs_request_processing_time_seconds, "processing_time", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
162
+
163
+ rrdlabels_add(ac->st_adcs_request_processing_time_seconds->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
164
+ }
165
+
166
+ rrddim_set_by_pointer(
167
+ ac->st_adcs_request_processing_time_seconds,
168
+ ac->rd_adcs_request_processing_time_seconds,
169
+ (collected_number)ac->ADCSRequestProcessingTime.current.Data);
170
+ rrdset_done(ac->st_adcs_request_processing_time_seconds);
171
+}
172
+
173
+static void netdata_adcs_retrievals(
174
+ struct adcs_certificate *ac,
175
+ PERF_DATA_BLOCK *pDataBlock,
176
+ PERF_OBJECT_TYPE *pObjectType,
177
+ int update_every)
178
+{
179
+ char id[RRD_ID_LENGTH_MAX + 1];
180
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSRetrievalsTotal)) {
181
+ return;
182
+ }
183
+
184
+ if (!ac->st_adcs_retrievals_total) {
185
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_retrievals", ac->name);
186
+ ac->st_adcs_retrievals_total = rrdset_create_localhost(
187
+ "adcs",
188
+ id,
189
+ NULL,
190
+ "retrievals",
191
+ "adcs.cert_retrievals",
192
+ "Total of certificate retrievals",
193
+ "retrievals/s",
194
+ PLUGIN_WINDOWS_NAME,
195
+ "PerflibADCS",
196
+ PRIO_ADCS_CERT_RETRIVALS,
197
+ update_every,
198
+ RRDSET_TYPE_LINE);
199
+
200
+ ac->rd_adcs_retrievals_total =
201
+ rrddim_add(ac->st_adcs_retrievals_total, "retrievals", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
202
+
203
+ rrdlabels_add(ac->st_adcs_retrievals_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
204
+ }
205
+
206
+ rrddim_set_by_pointer(
207
+ ac->st_adcs_retrievals_total,
208
+ ac->rd_adcs_retrievals_total,
209
+ (collected_number)ac->ADCSRetrievalsTotal.current.Data);
210
+ rrdset_done(ac->st_adcs_retrievals_total);
211
+}
212
+
213
+static void netdata_adcs_failed_requets(
214
+ struct adcs_certificate *ac,
215
+ PERF_DATA_BLOCK *pDataBlock,
216
+ PERF_OBJECT_TYPE *pObjectType,
217
+ int update_every)
218
+{
219
+ char id[RRD_ID_LENGTH_MAX + 1];
220
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSFailedRequestsTotal)) {
221
+ return;
222
+ }
223
+
224
+ if (!ac->st_adcs_failed_requests_total) {
225
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_failed_requests", ac->name);
226
+ ac->st_adcs_failed_requests_total = rrdset_create_localhost(
227
+ "adcs",
228
+ id,
229
+ NULL,
230
+ "requests",
231
+ "adcs.cert_failed_requests",
232
+ "Certificate failed requests processed",
233
+ "requests/s",
234
+ PLUGIN_WINDOWS_NAME,
235
+ "PerflibADCS",
236
+ PRIO_ADCS_CERT_FAILED_REQUESTS,
237
+ update_every,
238
+ RRDSET_TYPE_LINE);
239
+
240
+ ac->rd_adcs_failed_requests_total =
241
+ rrddim_add(ac->st_adcs_failed_requests_total, "failed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
242
+
243
+ rrdlabels_add(ac->st_adcs_failed_requests_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
244
+ }
245
+
246
+ rrddim_set_by_pointer(
247
+ ac->st_adcs_failed_requests_total,
248
+ ac->rd_adcs_failed_requests_total,
249
+ (collected_number)ac->ADCSFailedRequestsTotal.current.Data);
250
+ rrdset_done(ac->st_adcs_failed_requests_total);
251
+}
252
+
253
+static void netdata_adcs_issued_requets(
254
+ struct adcs_certificate *ac,
255
+ PERF_DATA_BLOCK *pDataBlock,
256
+ PERF_OBJECT_TYPE *pObjectType,
257
+ int update_every)
258
+{
259
+ char id[RRD_ID_LENGTH_MAX + 1];
260
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSIssuedRequestsTotal)) {
261
+ return;
262
+ }
263
+
264
+ if (!ac->st_adcs_issued_requests_total) {
265
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_issued_requests", ac->name);
266
+ ac->st_adcs_issued_requests_total = rrdset_create_localhost(
267
+ "adcs",
268
+ id,
269
+ NULL,
270
+ "requests",
271
+ "adcs.cert_issued_requests",
272
+ "Certificate issued requests processed",
273
+ "requests/s",
274
+ PLUGIN_WINDOWS_NAME,
275
+ "PerflibADCS",
276
+ PRIO_ADCS_CERT_ISSUED_REQUESTS,
277
+ update_every,
278
+ RRDSET_TYPE_LINE);
279
+
280
+ ac->rd_adcs_issued_requests_total =
281
+ rrddim_add(ac->st_adcs_issued_requests_total, "issued", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
282
+
283
+ rrdlabels_add(ac->st_adcs_issued_requests_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
284
+ }
285
+
286
+ rrddim_set_by_pointer(
287
+ ac->st_adcs_issued_requests_total,
288
+ ac->rd_adcs_issued_requests_total,
289
+ (collected_number)ac->ADCSIssuedRequestsTotal.current.Data);
290
+ rrdset_done(ac->st_adcs_issued_requests_total);
291
+}
292
+
293
+static void netdata_adcs_pending_requets(
294
+ struct adcs_certificate *ac,
295
+ PERF_DATA_BLOCK *pDataBlock,
296
+ PERF_OBJECT_TYPE *pObjectType,
297
+ int update_every)
298
+{
299
+ char id[RRD_ID_LENGTH_MAX + 1];
300
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSPendingRequestsTotal)) {
301
+ return;
302
+ }
303
+
304
+ if (!ac->st_adcs_pending_requests_total) {
305
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_pending_requests", ac->name);
306
+ ac->st_adcs_pending_requests_total = rrdset_create_localhost(
307
+ "adcs",
308
+ id,
309
+ NULL,
310
+ "requests",
311
+ "adcs.cert_pending_requests",
312
+ "Certificate pending requests processed",
313
+ "requests/s",
314
+ PLUGIN_WINDOWS_NAME,
315
+ "PerflibADCS",
316
+ PRIO_ADCS_CERT_PENDING_REQUESTS,
317
+ update_every,
318
+ RRDSET_TYPE_LINE);
319
+
320
+ ac->rd_adcs_pending_requests_total =
321
+ rrddim_add(ac->st_adcs_pending_requests_total, "pending", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
322
+
323
+ rrdlabels_add(ac->st_adcs_pending_requests_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
324
+ }
325
+
326
+ rrddim_set_by_pointer(
327
+ ac->st_adcs_pending_requests_total,
328
+ ac->rd_adcs_pending_requests_total,
329
+ (collected_number)ac->ADCSPendingRequestsTotal.current.Data);
330
+ rrdset_done(ac->st_adcs_pending_requests_total);
331
+}
332
+
333
+static void netdata_adcs_challenge_response(
334
+ struct adcs_certificate *ac,
335
+ PERF_DATA_BLOCK *pDataBlock,
336
+ PERF_OBJECT_TYPE *pObjectType,
337
+ int update_every)
338
+{
339
+ char id[RRD_ID_LENGTH_MAX + 1];
340
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSChallengeResponseResponsesTotal)) {
341
+ return;
342
+ }
343
+
344
+ if (!ac->st_adcs_challenge_responses_total) {
345
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_challenge_responses", ac->name);
346
+ ac->st_adcs_challenge_responses_total = rrdset_create_localhost(
347
+ "adcs",
348
+ id,
349
+ NULL,
350
+ "responses",
351
+ "adcs.cert_challenge_responses",
352
+ "Certificate challenge responses",
353
+ "responses/s",
354
+ PLUGIN_WINDOWS_NAME,
355
+ "PerflibADCS",
356
+ PRIO_ADCS_CERT_CHALLENGE_RESPONSES,
357
+ update_every,
358
+ RRDSET_TYPE_LINE);
359
+
360
+ ac->rd_adcs_challenge_responses_total =
361
+ rrddim_add(ac->st_adcs_challenge_responses_total, "challenge", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
362
+
363
+ rrdlabels_add(ac->st_adcs_challenge_responses_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
364
+ }
365
+
366
+ rrddim_set_by_pointer(
367
+ ac->st_adcs_challenge_responses_total,
368
+ ac->rd_adcs_challenge_responses_total,
369
+ (collected_number)ac->ADCSChallengeResponseResponsesTotal.current.Data);
370
+ rrdset_done(ac->st_adcs_challenge_responses_total);
371
+}
372
+
373
+static void netdata_adcs_retrieval_processing(
374
+ struct adcs_certificate *ac,
375
+ PERF_DATA_BLOCK *pDataBlock,
376
+ PERF_OBJECT_TYPE *pObjectType,
377
+ int update_every)
378
+{
379
+ char id[RRD_ID_LENGTH_MAX + 1];
380
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSRetrievalsProcessingTime)) {
381
+ return;
382
+ }
383
+
384
+ if (!ac->st_adcs_challenge_response_processing_time_seconds) {
385
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_retrievals_processing_time", ac->name);
386
+ ac->st_adcs_challenge_response_processing_time_seconds = rrdset_create_localhost(
387
+ "adcs",
388
+ id,
389
+ NULL,
390
+ "retrievals",
391
+ "adcs.cert_retrieval_processing_time",
392
+ "Certificate last retrieval processing time",
393
+ "seconds",
394
+ PLUGIN_WINDOWS_NAME,
395
+ "PerflibADCS",
396
+ PRIO_ADCS_CERT_RETRIEVAL_PROCESSING_TIME,
397
+ update_every,
398
+ RRDSET_TYPE_LINE);
399
+
400
+ ac->rd_adcs_challenge_response_processing_time_seconds = rrddim_add(
401
+ ac->st_adcs_challenge_response_processing_time_seconds,
402
+ "processing_time",
403
+ NULL,
404
+ 1,
405
+ 1000,
406
+ RRD_ALGORITHM_ABSOLUTE);
407
+
408
+ rrdlabels_add(
409
+ ac->st_adcs_challenge_response_processing_time_seconds->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
410
+ }
411
+
412
+ rrddim_set_by_pointer(
413
+ ac->st_adcs_challenge_response_processing_time_seconds,
414
+ ac->rd_adcs_challenge_response_processing_time_seconds,
415
+ (collected_number)ac->ADCSRetrievalsProcessingTime.current.Data);
416
+ rrdset_done(ac->st_adcs_challenge_response_processing_time_seconds);
417
+}
418
+
419
+static void netdata_adcs_crypto_singing_time(
420
+ struct adcs_certificate *ac,
421
+ PERF_DATA_BLOCK *pDataBlock,
422
+ PERF_OBJECT_TYPE *pObjectType,
423
+ int update_every)
424
+{
425
+ char id[RRD_ID_LENGTH_MAX + 1];
426
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSRetrievalsProcessingTime)) {
427
+ return;
428
+ }
429
+
430
+ if (!ac->st_adcs_request_cryptographic_signing_time_seconds) {
431
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_request_cryptographic_signing_time", ac->name);
432
+ ac->st_adcs_request_cryptographic_signing_time_seconds = rrdset_create_localhost(
433
+ "adcs",
434
+ id,
435
+ NULL,
436
+ "timings",
437
+ "adcs.cert_request_cryptographic_signing_time",
438
+ "Certificate last signing operation request time",
439
+ "seconds",
440
+ PLUGIN_WINDOWS_NAME,
441
+ "PerflibADCS",
442
+ PRIO_ADCS_CERT_REQ_CRYPTO_SIGNING_TIME,
443
+ update_every,
444
+ RRDSET_TYPE_LINE);
445
+
446
+ ac->rd_adcs_request_cryptographic_signing_time_seconds = rrddim_add(
447
+ ac->st_adcs_request_cryptographic_signing_time_seconds,
448
+ "singing_time",
449
+ NULL,
450
+ 1,
451
+ 1000,
452
+ RRD_ALGORITHM_ABSOLUTE);
453
+
454
+ rrdlabels_add(
455
+ ac->st_adcs_request_cryptographic_signing_time_seconds->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
456
+ }
457
+
458
+ rrddim_set_by_pointer(
459
+ ac->st_adcs_request_cryptographic_signing_time_seconds,
460
+ ac->rd_adcs_request_cryptographic_signing_time_seconds,
461
+ (collected_number)ac->ADCSRetrievalsProcessingTime.current.Data);
462
+ rrdset_done(ac->st_adcs_request_cryptographic_signing_time_seconds);
463
+}
464
+
465
+static void netdata_adcs_policy_mod_processing_time(
466
+ struct adcs_certificate *ac,
467
+ PERF_DATA_BLOCK *pDataBlock,
468
+ PERF_OBJECT_TYPE *pObjectType,
469
+ int update_every)
470
+{
471
+ char id[RRD_ID_LENGTH_MAX + 1];
472
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSRequestPolicyModuleProcessingTime)) {
473
+ return;
474
+ }
475
+
476
+ if (!ac->st_adcs_request_policy_module_processing_time_seconds) {
477
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_request_policy_module_processing_time", ac->name);
478
+ ac->st_adcs_request_policy_module_processing_time_seconds = rrdset_create_localhost(
479
+ "adcs",
480
+ id,
481
+ NULL,
482
+ "timings",
483
+ "adcs.cert_request_policy_module_processing",
484
+ "Certificate last policy module processing request time",
485
+ "seconds",
486
+ PLUGIN_WINDOWS_NAME,
487
+ "PerflibADCS",
488
+ PRIO_ADCS_CERT_REQ_POLICY_MODULE_PROCESS_TIME,
489
+ update_every,
490
+ RRDSET_TYPE_LINE);
491
+
492
+ ac->rd_adcs_request_policy_module_processing_time_seconds = rrddim_add(
493
+ ac->st_adcs_request_policy_module_processing_time_seconds,
494
+ "processing_time",
495
+ NULL,
496
+ 1,
497
+ 1000,
498
+ RRD_ALGORITHM_ABSOLUTE);
499
+
500
+ rrdlabels_add(
501
+ ac->st_adcs_request_policy_module_processing_time_seconds->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
502
+ }
503
+
504
+ rrddim_set_by_pointer(
505
+ ac->st_adcs_request_policy_module_processing_time_seconds,
506
+ ac->rd_adcs_request_policy_module_processing_time_seconds,
507
+ (collected_number)ac->ADCSRequestPolicyModuleProcessingTime.current.Data);
508
+ rrdset_done(ac->st_adcs_request_policy_module_processing_time_seconds);
509
+}
510
+
511
+static void netdata_adcs_challenge_response_processing_time(
512
+ struct adcs_certificate *ac,
513
+ PERF_DATA_BLOCK *pDataBlock,
514
+ PERF_OBJECT_TYPE *pObjectType,
515
+ int update_every)
516
+{
517
+ char id[RRD_ID_LENGTH_MAX + 1];
518
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSChallengeResponseProcessingTime)) {
519
+ return;
520
+ }
521
+
522
+ if (!ac->st_adcs_challenge_response_processing_time_seconds) {
523
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_challenge_response_processing_time", ac->name);
524
+ ac->st_adcs_challenge_response_processing_time_seconds = rrdset_create_localhost(
525
+ "adcs",
526
+ id,
527
+ NULL,
528
+ "timings",
529
+ "adcs.cert_challenge_response_processing_time",
530
+ "Certificate last challenge response time",
531
+ "seconds",
532
+ PLUGIN_WINDOWS_NAME,
533
+ "PerflibADCS",
534
+ PRIO_ADCS_CERT_CHALLENGE_RESP_PROCESSING_TIME,
535
+ update_every,
536
+ RRDSET_TYPE_LINE);
537
+
538
+ ac->rd_adcs_challenge_response_processing_time_seconds = rrddim_add(
539
+ ac->st_adcs_challenge_response_processing_time_seconds,
540
+ "processing_time",
541
+ NULL,
542
+ 1,
543
+ 1000,
544
+ RRD_ALGORITHM_ABSOLUTE);
545
+
546
+ rrdlabels_add(
547
+ ac->st_adcs_challenge_response_processing_time_seconds->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
548
+ }
549
+
550
+ rrddim_set_by_pointer(
551
+ ac->st_adcs_challenge_response_processing_time_seconds,
552
+ ac->rd_adcs_challenge_response_processing_time_seconds,
553
+ (collected_number)ac->ADCSChallengeResponseProcessingTime.current.Data);
554
+ rrdset_done(ac->st_adcs_challenge_response_processing_time_seconds);
555
+}
556
+
557
+static void netdata_adcs_signed_certificate_timetamp_list(
558
+ struct adcs_certificate *ac,
559
+ PERF_DATA_BLOCK *pDataBlock,
560
+ PERF_OBJECT_TYPE *pObjectType,
561
+ int update_every)
562
+{
563
+ char id[RRD_ID_LENGTH_MAX + 1];
564
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSSignedCertTimestampListsTotal)) {
565
+ return;
566
+ }
567
+
568
+ if (!ac->st_adcs_signed_certificate_timestamp_lists_total) {
569
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_signed_certificate_timestamp_lists", ac->name);
570
+ ac->st_adcs_signed_certificate_timestamp_lists_total = rrdset_create_localhost(
571
+ "adcs",
572
+ id,
573
+ NULL,
574
+ "timings",
575
+ "adcs.cert_signed_certificate_timestamp_lists",
576
+ "Certificate Signed Certificate Timestamp Lists processed",
577
+ "lists/s",
578
+ PLUGIN_WINDOWS_NAME,
579
+ "PerflibADCS",
580
+ PRIO_ADCS_CERT_SIGNED_CERTIFICATE_TIMESTAMP_LIST,
581
+ update_every,
582
+ RRDSET_TYPE_LINE);
583
+
584
+ ac->rd_adcs_signed_certificate_timestamp_lists_total = rrddim_add(
585
+ ac->st_adcs_signed_certificate_timestamp_lists_total,
586
+ "processing_time",
587
+ NULL,
588
+ 1,
589
+ 1,
590
+ RRD_ALGORITHM_INCREMENTAL);
591
+
592
+ rrdlabels_add(
593
+ ac->st_adcs_signed_certificate_timestamp_lists_total->rrdlabels, "cert", ac->name, RRDLABEL_SRC_AUTO);
594
+ }
595
+
596
+ rrddim_set_by_pointer(
597
+ ac->st_adcs_signed_certificate_timestamp_lists_total,
598
+ ac->rd_adcs_signed_certificate_timestamp_lists_total,
599
+ (collected_number)ac->ADCSSignedCertTimestampListsTotal.current.Data);
600
+ rrdset_done(ac->st_adcs_signed_certificate_timestamp_lists_total);
601
+}
602
+
603
+static void netdata_adcs_signed_certificate_timetamp_list_processing(
604
+ struct adcs_certificate *ac,
605
+ PERF_DATA_BLOCK *pDataBlock,
606
+ PERF_OBJECT_TYPE *pObjectType,
607
+ int update_every)
608
+{
609
+ char id[RRD_ID_LENGTH_MAX + 1];
610
+ if (!perflibGetObjectCounter(pDataBlock, pObjectType, &ac->ADCSSignedCertTimestampListProcessingTime)) {
611
+ return;
612
+ }
613
+
614
+ if (!ac->st_adcs_signed_certificate_timestamp_list_processing_time_seconds) {
615
+ snprintfz(id, RRD_ID_LENGTH_MAX, "cert_%s_signed_certificate_timestamp_list_processing_time", ac->name);
616
+ ac->st_adcs_signed_certificate_timestamp_list_processing_time_seconds = rrdset_create_localhost(
617
+ "adcs",
618
+ id,
619
+ NULL,
620
+ "timings",
621
+ "adcs.cert_signed_certificate_timestamp_list_processing_time",
622
+ "Certificate last Signed Certificate Timestamp List process time",
623
+ "seconds",
624
+ PLUGIN_WINDOWS_NAME,
625
+ "PerflibADCS",
626
+ PRIO_ADCS_CERT_SIGNED_CERTIFICATE_TIMESTAMP_PROC_TIME_LIST,
627
+ update_every,
628
+ RRDSET_TYPE_LINE);
629
+
630
+ ac->rd_adcs_signed_certificate_timestamp_list_processing_time_seconds = rrddim_add(
631
+ ac->st_adcs_signed_certificate_timestamp_list_processing_time_seconds,
632
+ "processing_time",
633
+ NULL,
634
+ 1,
635
+ 1000,
636
+ RRD_ALGORITHM_ABSOLUTE);
637
+
638
+ rrdlabels_add(
639
+ ac->st_adcs_signed_certificate_timestamp_list_processing_time_seconds->rrdlabels,
640
+ "cert",
641
+ ac->name,
642
+ RRDLABEL_SRC_AUTO);
643
+ }
644
+
645
+ rrddim_set_by_pointer(
646
+ ac->st_adcs_signed_certificate_timestamp_list_processing_time_seconds,
647
+ ac->rd_adcs_signed_certificate_timestamp_list_processing_time_seconds,
648
+ (collected_number)ac->ADCSSignedCertTimestampListProcessingTime.current.Data);
649
+ rrdset_done(ac->st_adcs_signed_certificate_timestamp_list_processing_time_seconds);
650
+}
651
+
652
+static bool do_ADCS(PERF_DATA_BLOCK *pDataBlock, int update_every)
653
+{
654
+ PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, "Certification Authority");
655
+ if (!pObjectType)
656
+ return false;
657
+
658
+ static void (*doADCS[])(struct adcs_certificate *, PERF_DATA_BLOCK *, PERF_OBJECT_TYPE *, int) = {
659
+ netdata_adcs_requests,
660
+ netdata_adcs_requests_processing_time,
661
+ netdata_adcs_retrievals,
662
+ netdata_adcs_failed_requets,
663
+ netdata_adcs_issued_requets,
664
+ netdata_adcs_pending_requets,
665
+
666
+ netdata_adcs_challenge_response,
667
+
668
+ netdata_adcs_retrieval_processing,
669
+
670
+ netdata_adcs_crypto_singing_time,
671
+ netdata_adcs_policy_mod_processing_time,
672
+ netdata_adcs_challenge_response_processing_time,
673
+ netdata_adcs_signed_certificate_timetamp_list,
674
+ netdata_adcs_signed_certificate_timetamp_list_processing,
675
+ netdata_adcs_retrieval_processing,
676
+
677
+ // This must be the end
678
+ NULL};
679
+
680
+ PERF_INSTANCE_DEFINITION *pi = NULL;
681
+ for (LONG i = 0; i < pObjectType->NumInstances; i++) {
682
+ pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
683
+ if (!pi)
684
+ break;
685
+
686
+ if (!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))
687
+ strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
688
+
689
+ if (strcasecmp(windows_shared_buffer, "_Total") == 0)
690
+ continue;
691
+
692
+ struct adcs_certificate *ptr = dictionary_set(adcs_certificates, windows_shared_buffer, NULL, sizeof(*ptr));
693
+
694
+ for (int i = 0; doADCS[i]; i++)
695
+ doADCS[i](ptr, pDataBlock, pObjectType, update_every);
696
+ }
697
+
698
+ return true;
699
+}
700
+
701
+int do_PerflibADCS(int update_every, usec_t dt __maybe_unused)
702
+{
703
+ static bool initialized = false;
704
+
705
+ if (unlikely(!initialized)) {
706
+ initialize();
707
+ initialized = true;
708
+ }
709
+
710
+ DWORD id = RegistryFindIDByName("Certification Authority");
711
+ if (id == PERFLIB_REGISTRY_NAME_NOT_FOUND)
712
+ return -1;
713
+
714
+ PERF_DATA_BLOCK *pDataBlock = perflibGetPerformanceData(id);
715
+ if (!pDataBlock)
716
+ return -1;
717
+
718
+ do_ADCS(pDataBlock, update_every);
719
+
720
+ return 0;
721
+}
src/collectors/windows.plugin/windows_plugin.c
+42
-26
@@ -13,39 +13,53 @@ static struct proc_module {
13
} win_modules[] = {
14
15
// system metrics
16
- {.name = "GetSystemUptime", .dim = "GetSystemUptime", .enabled = CONFIG_BOOLEAN_YES, .func = do_GetSystemUptime},
17
- {.name = "GetSystemRAM", .dim = "GetSystemRAM", .enabled = CONFIG_BOOLEAN_YES, .func = do_GetSystemRAM},
16
+ {.name = "GetSystemUptime", .dim = "GetSystemUptime", .enabled = CONFIG_BOOLEAN_YES, .func = do_GetSystemUptime},
17
+ {.name = "GetSystemRAM", .dim = "GetSystemRAM", .enabled = CONFIG_BOOLEAN_YES, .func = do_GetSystemRAM},
18
19
// the same is provided by PerflibProcessor, with more detailed analysis
20
//{.name = "GetSystemCPU", .dim = "GetSystemCPU", .enabled = CONFIG_BOOLEAN_YES, .func = do_GetSystemCPU},
21
22
- {.name = "PerflibProcesses", .dim = "PerflibProcesses", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibProcesses},
23
- {.name = "PerflibProcessor", .dim = "PerflibProcessor", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibProcessor},
24
- {.name = "PerflibMemory", .dim = "PerflibMemory", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibMemory},
25
- {.name = "PerflibStorage", .dim = "PerflibStorage", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibStorage},
26
- {.name = "PerflibNetwork", .dim = "PerflibNetwork", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibNetwork},
27
- {.name = "PerflibObjects", .dim = "PerflibObjects", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibObjects},
28
- {.name = "PerflibHyperV", .dim = "PerflibHyperV", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibHyperV},
22
+ {.name = "PerflibProcesses", .dim = "PerflibProcesses", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibProcesses},
23
+ {.name = "PerflibProcessor", .dim = "PerflibProcessor", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibProcessor},
24
+ {.name = "PerflibMemory", .dim = "PerflibMemory", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibMemory},
25
+ {.name = "PerflibStorage", .dim = "PerflibStorage", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibStorage},
26
+ {.name = "PerflibNetwork", .dim = "PerflibNetwork", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibNetwork},
27
+ {.name = "PerflibObjects", .dim = "PerflibObjects", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibObjects},
28
+ {.name = "PerflibHyperV", .dim = "PerflibHyperV", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibHyperV},
29
30
- {.name = "PerflibThermalZone", .dim = "PerflibThermalZone", .enabled = CONFIG_BOOLEAN_NO, .func = do_PerflibThermalZone},
30
+ {.name = "PerflibThermalZone",
31
+ .dim = "PerflibThermalZone",
32
+ .enabled = CONFIG_BOOLEAN_NO,
33
+ .func = do_PerflibThermalZone},
34
32
- {.name = "PerflibWebService", .dim = "PerflibWebService", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibWebService},
33
- {.name = "PerflibMSSQL", .dim = "PerflibMSSQL", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibMSSQL},
35
+ {.name = "PerflibWebService",
36
+ .dim = "PerflibWebService",
37
+ .enabled = CONFIG_BOOLEAN_YES,
38
+ .func = do_PerflibWebService},
39
+ {.name = "PerflibMSSQL", .dim = "PerflibMSSQL", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibMSSQL},
40
35
- {.name = "PerflibNetFramework", .dim = "PerflibNetFramework", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibNetFramework},
36
- {.name = "PerflibAD", .dim = "PerflibAD", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibAD},
41
+ {.name = "PerflibNetFramework",
42
+ .dim = "PerflibNetFramework",
43
+ .enabled = CONFIG_BOOLEAN_YES,
44
+ .func = do_PerflibNetFramework},
45
+ {.name = "PerflibAD", .dim = "PerflibAD", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibAD},
46
+
47
+ {.name = "PerflibADCS", .dim = "PerflibADCS", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibADCS},
48
+
49
+ {.name = "PerflibADCS", .dim = "PerflibADCS", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibADCS},
50
51
// the terminator of this array
39
- {.name = NULL, .dim = NULL, .func = NULL}
40
-};
52
+ {.name = NULL, .dim = NULL, .func = NULL}};
53
54
#if WORKER_UTILIZATION_MAX_JOB_TYPES < 36
55
#error WORKER_UTILIZATION_MAX_JOB_TYPES has to be at least 36
56
#endif
57
46
-static void windows_main_cleanup(void *pptr) {
58
+static void windows_main_cleanup(void *pptr)
59
+{
60
struct netdata_static_thread *static_thread = CLEANUP_FUNCTION_GET_PTR(pptr);
48
- if(!static_thread) return;
61
+ if (!static_thread)
62
+ return;
63
64
static_thread->enabled = NETDATA_MAIN_THREAD_EXITING;
65
@@ -54,13 +68,15 @@ static void windows_main_cleanup(void *pptr) {
68
worker_unregister();
69
}
70
57
-static bool log_windows_module(BUFFER *wb, void *data) {
71
+static bool log_windows_module(BUFFER *wb, void *data)
72
+{
73
struct proc_module *pm = data;
74
buffer_sprintf(wb, PLUGIN_WINDOWS_NAME "[%s]", pm->name);
75
return true;
76
}
77
63
-void *win_plugin_main(void *ptr) {
78
+void *win_plugin_main(void *ptr)
79
+{
80
worker_register("WIN");
81
82
rrd_collector_started();
@@ -70,7 +86,7 @@ void *win_plugin_main(void *ptr) {
86
87
// check the enabled status for each module
88
int i;
73
- for(i = 0; win_modules[i].name; i++) {
89
+ for (i = 0; win_modules[i].name; i++) {
90
struct proc_module *pm = &win_modules[i];
91
92
pm->enabled = config_get_boolean("plugin:windows", pm->name, pm->enabled);
@@ -90,21 +106,21 @@ void *win_plugin_main(void *ptr) {
106
};
107
ND_LOG_STACK_PUSH(lgs);
108
93
- while(service_running(SERVICE_COLLECTORS)) {
109
+ while (service_running(SERVICE_COLLECTORS)) {
110
worker_is_idle();
111
usec_t hb_dt = heartbeat_next(&hb);
112
97
- if(unlikely(!service_running(SERVICE_COLLECTORS)))
113
+ if (unlikely(!service_running(SERVICE_COLLECTORS)))
114
break;
115
116
PerflibNamesRegistryUpdate();
117
102
- for(i = 0; win_modules[i].name; i++) {
103
- if(unlikely(!service_running(SERVICE_COLLECTORS)))
118
+ for (i = 0; win_modules[i].name; i++) {
119
+ if (unlikely(!service_running(SERVICE_COLLECTORS)))
120
break;
121
122
struct proc_module *pm = &win_modules[i];
107
- if(unlikely(!pm->enabled))
123
+ if (unlikely(!pm->enabled))
124
continue;
125
126
worker_is_busy(i);
src/collectors/windows.plugin/windows_plugin.h
+17
-2
@@ -29,6 +29,7 @@ int do_PerflibWebService(int update_every, usec_t dt);
29
int do_PerflibMSSQL(int update_every, usec_t dt);
30
int do_PerflibNetFramework(int update_every, usec_t dt);
31
int do_PerflibAD(int update_every, usec_t dt);
32
+int do_PerflibADCS(int update_every, usec_t dt);
33
34
enum PERFLIB_PRIO {
35
PRIO_WEBSITE_IIS_REQUESTS_RATE = 21000, // PRIO selected, because APPS is using 20YYY
@@ -122,8 +123,8 @@ enum PERFLIB_PRIO {
123
PRIO_AD_DIROPERATIONS_TOTAL,
124
PRIO_AD_CACHE_LOOKUP_TOTAL,
125
PRIO_AD_CACHE_HITS_TOTAL,
125
- PRIO_AD_REPLICATION_INTERSITE_COMPRESSED,
126
PRIO_AD_REPLICATION_INTRASITE_COMPRESSED,
127
+ PRIO_AD_REPLICATION_INTERSITE_COMPRESSED,
128
PRIO_AD_SYNC_OBJECTS_REMAINING,
129
PRIO_AD_REPLICATION_PROPERTY_UPDATED,
130
PRIO_AD_REPLICATION_PROPERTY_FILTERED,
@@ -134,7 +135,21 @@ enum PERFLIB_PRIO {
135
PRIO_AD_BIND_TOTAL,
136
PRIO_AD_LDAP_SEARCHES_TOTAL,
137
PRIO_AD_AVG_REQUEST_LATENCY,
137
- PRIO_AD_OUTSTANDING_REQUEST
138
+ PRIO_AD_OUTSTANDING_REQUEST,
139
+
140
+ PRIO_ADCS_CERT_REQUESTS_TOTAL,
141
+ PRIO_ADCS_CERT_REQUESTS_PROCESSING_TIME,
142
+ PRIO_ADCS_CERT_RETRIVALS,
143
+ PRIO_ADCS_CERT_FAILED_REQUESTS,
144
+ PRIO_ADCS_CERT_ISSUED_REQUESTS,
145
+ PRIO_ADCS_CERT_PENDING_REQUESTS,
146
+ PRIO_ADCS_CERT_CHALLENGE_RESPONSES,
147
+ PRIO_ADCS_CERT_RETRIEVAL_PROCESSING_TIME,
148
+ PRIO_ADCS_CERT_REQ_CRYPTO_SIGNING_TIME,
149
+ PRIO_ADCS_CERT_REQ_POLICY_MODULE_PROCESS_TIME,
150
+ PRIO_ADCS_CERT_CHALLENGE_RESP_PROCESSING_TIME,
151
+ PRIO_ADCS_CERT_SIGNED_CERTIFICATE_TIMESTAMP_LIST,
152
+ PRIO_ADCS_CERT_SIGNED_CERTIFICATE_TIMESTAMP_PROC_TIME_LIST
153
};
154
155
int do_PerflibHyperV(int update_every, usec_t dt);