@cryptotaxi247 / netdata-1 / commits / fcd81cf53

chore(windows.plugin): format perflib ad and netframework (#19544)

Ilya Mashchenko committed Jan 31, 2025 at 15:26 UTC fcd81cf537a288ff61a0f91205a9f57a12ca442e
2 files changed +834 -917
src/collectors/windows.plugin/perflib-ad.c
+458 -525
@@ -3,34 +3,36 @@
3 #include "windows_plugin.h"
4 #include "windows-internals.h"
5
6 -static void initialize(void) {
6 +static void initialize(void)
7 +{
8 ;
9 }
10
10 -static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
11 - static COUNTER_DATA directoryPercReadsFromDCA = { .key = "DS % Reads from DRA" };
12 - static COUNTER_DATA directoryPercReadsFromKCC = { .key = "DS % Reads from KCC" };
13 - static COUNTER_DATA directoryPercReadsFromLSA = { .key = "DS % Reads from LSA" };
14 - static COUNTER_DATA directoryPercReadsFromNSPI = { .key = "DS % Reads from NSPI" };
15 - static COUNTER_DATA directoryPercReadsFromNTDSAPI = { .key = "DS % Reads from NTDSAPI" };
16 - static COUNTER_DATA directoryPercReadsFromSAM = { .key = "DS % Reads from SAM" };
17 - static COUNTER_DATA directoryPercReadsOther = { .key = "DS % Reads from Other" };
18 -
19 - static COUNTER_DATA directoryPercSearchesFromDCA = { .key = "DS % Searches from DRA" };
20 - static COUNTER_DATA directoryPercSearchesFromKCC = { .key = "DS % Searches from KCC" };
21 - static COUNTER_DATA directoryPercSearchesFromLSA = { .key = "DS % Searches from LSA" };
22 - static COUNTER_DATA directoryPercSearchesFromNSPI = { .key = "DS % Searches from NSPI" };
23 - static COUNTER_DATA directoryPercSearchesFromNTDSAPI = { .key = "DS % Searches from NTDSAPI" };
24 - static COUNTER_DATA directoryPercSearchesFromSAM = { .key = "DS % Searches from SAM" };
25 - static COUNTER_DATA directoryPercSearchesOther = { .key = "DS % Searches from Other" };
26 -
27 - static COUNTER_DATA directoryPercWritesFromDCA = { .key = "DS % Writes from DRA" };
28 - static COUNTER_DATA directoryPercWritesFromKCC = { .key = "DS % Writes from KCC" };
29 - static COUNTER_DATA directoryPercWritesFromLSA = { .key = "DS % Writes from LSA" };
30 - static COUNTER_DATA directoryPercWritesFromNSPI = { .key = "DS % Writes from NSPI" };
31 - static COUNTER_DATA directoryPercWritesFromNTDSAPI = { .key = "DS % Writes from NTDSAPI" };
32 - static COUNTER_DATA directoryPercWritesFromSAM = { .key = "DS % Writes from SAM" };
33 - static COUNTER_DATA directoryPercWritesOther = { .key = "DS % Writes from Other" };
11 +static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
12 +{
13 + static COUNTER_DATA directoryPercReadsFromDCA = {.key = "DS % Reads from DRA"};
14 + static COUNTER_DATA directoryPercReadsFromKCC = {.key = "DS % Reads from KCC"};
15 + static COUNTER_DATA directoryPercReadsFromLSA = {.key = "DS % Reads from LSA"};
16 + static COUNTER_DATA directoryPercReadsFromNSPI = {.key = "DS % Reads from NSPI"};
17 + static COUNTER_DATA directoryPercReadsFromNTDSAPI = {.key = "DS % Reads from NTDSAPI"};
18 + static COUNTER_DATA directoryPercReadsFromSAM = {.key = "DS % Reads from SAM"};
19 + static COUNTER_DATA directoryPercReadsOther = {.key = "DS % Reads from Other"};
20 +
21 + static COUNTER_DATA directoryPercSearchesFromDCA = {.key = "DS % Searches from DRA"};
22 + static COUNTER_DATA directoryPercSearchesFromKCC = {.key = "DS % Searches from KCC"};
23 + static COUNTER_DATA directoryPercSearchesFromLSA = {.key = "DS % Searches from LSA"};
24 + static COUNTER_DATA directoryPercSearchesFromNSPI = {.key = "DS % Searches from NSPI"};
25 + static COUNTER_DATA directoryPercSearchesFromNTDSAPI = {.key = "DS % Searches from NTDSAPI"};
26 + static COUNTER_DATA directoryPercSearchesFromSAM = {.key = "DS % Searches from SAM"};
27 + static COUNTER_DATA directoryPercSearchesOther = {.key = "DS % Searches from Other"};
28 +
29 + static COUNTER_DATA directoryPercWritesFromDCA = {.key = "DS % Writes from DRA"};
30 + static COUNTER_DATA directoryPercWritesFromKCC = {.key = "DS % Writes from KCC"};
31 + static COUNTER_DATA directoryPercWritesFromLSA = {.key = "DS % Writes from LSA"};
32 + static COUNTER_DATA directoryPercWritesFromNSPI = {.key = "DS % Writes from NSPI"};
33 + static COUNTER_DATA directoryPercWritesFromNTDSAPI = {.key = "DS % Writes from NTDSAPI"};
34 + static COUNTER_DATA directoryPercWritesFromSAM = {.key = "DS % Writes from SAM"};
35 + static COUNTER_DATA directoryPercWritesOther = {.key = "DS % Writes from Other"};
36
37 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercReadsFromDCA);
38 perflibGetObjectCounter(pDataBlock, pObjectType, &directoryPercReadsFromKCC);
@@ -61,195 +63,160 @@ static void netdata_ad_directory(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *
63 static RRDDIM *rd_directory_operation_total_write = NULL;
64 static RRDDIM *rd_directory_operation_total_search = NULL;
65
64 -
66 if (unlikely(!st_directory_operation_total)) {
66 - st_directory_operation_total = rrdset_create_localhost("ad"
67 - , "directory_operations_read"
68 - , NULL
69 - , "database"
70 - , "ad.directory_operations"
71 - , "AD directory operations"
72 - , "operations/s"
73 - , PLUGIN_WINDOWS_NAME
74 - , "PerflibAD"
75 - , PRIO_AD_DIROPERATIONS_TOTAL
76 - , update_every
77 - , RRDSET_TYPE_LINE);
78 -
79 - rd_directory_operation_total_read = rrddim_add(st_directory_operation_total,
80 - "read",
81 - NULL,
82 - 1,
83 - 1,
84 - RRD_ALGORITHM_INCREMENTAL);
85 -
86 - rd_directory_operation_total_write = rrddim_add(st_directory_operation_total,
87 - "write",
88 - NULL,
89 - 1,
90 - 1,
91 - RRD_ALGORITHM_INCREMENTAL);
92 -
93 - rd_directory_operation_total_search = rrddim_add(st_directory_operation_total,
94 - "search",
95 - NULL,
96 - 1,
97 - 1,
98 - RRD_ALGORITHM_INCREMENTAL);
67 + st_directory_operation_total = rrdset_create_localhost(
68 + "ad",
69 + "directory_operations_read",
70 + NULL,
71 + "database",
72 + "ad.directory_operations",
73 + "AD directory operations",
74 + "operations/s",
75 + PLUGIN_WINDOWS_NAME,
76 + "PerflibAD",
77 + PRIO_AD_DIROPERATIONS_TOTAL,
78 + update_every,
79 + RRDSET_TYPE_LINE);
80 +
81 + rd_directory_operation_total_read =
82 + rrddim_add(st_directory_operation_total, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
83 +
84 + rd_directory_operation_total_write =
85 + rrddim_add(st_directory_operation_total, "write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
86 +
87 + rd_directory_operation_total_search =
88 + rrddim_add(st_directory_operation_total, "search", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
89 }
100 - collected_number readValue = directoryPercReadsFromDCA.current.Data +
101 - directoryPercReadsFromKCC.current.Data +
102 - directoryPercReadsFromLSA.current.Data +
103 - directoryPercReadsFromNSPI.current.Data +
104 - directoryPercReadsFromNTDSAPI.current.Data +
105 - directoryPercReadsFromSAM.current.Data +
106 - directoryPercReadsOther.current.Data ;
107 -
108 - collected_number writeValue = directoryPercWritesFromDCA.current.Data +
109 - directoryPercWritesFromKCC.current.Data +
110 - directoryPercWritesFromLSA.current.Data +
111 - directoryPercWritesFromNSPI.current.Data +
112 - directoryPercWritesFromNTDSAPI.current.Data +
113 - directoryPercWritesFromSAM.current.Data +
114 - directoryPercWritesOther.current.Data ;
115 -
116 - collected_number searchValue = directoryPercSearchesFromDCA.current.Data +
117 - directoryPercSearchesFromKCC.current.Data +
118 - directoryPercSearchesFromLSA.current.Data +
119 - directoryPercSearchesFromNSPI.current.Data +
120 - directoryPercSearchesFromNTDSAPI.current.Data +
121 - directoryPercSearchesFromSAM.current.Data +
122 - directoryPercSearchesOther.current.Data ;
123 -
124 - rrddim_set_by_pointer(st_directory_operation_total,
125 - rd_directory_operation_total_read,
126 - readValue);
127 -
128 - rrddim_set_by_pointer(st_directory_operation_total,
129 - rd_directory_operation_total_write,
130 - writeValue);
131 -
132 - rrddim_set_by_pointer(st_directory_operation_total,
133 - rd_directory_operation_total_search,
134 - searchValue);
90 + collected_number readValue = directoryPercReadsFromDCA.current.Data + directoryPercReadsFromKCC.current.Data +
91 + directoryPercReadsFromLSA.current.Data + directoryPercReadsFromNSPI.current.Data +
92 + directoryPercReadsFromNTDSAPI.current.Data + directoryPercReadsFromSAM.current.Data +
93 + directoryPercReadsOther.current.Data;
94 +
95 + collected_number writeValue = directoryPercWritesFromDCA.current.Data + directoryPercWritesFromKCC.current.Data +
96 + directoryPercWritesFromLSA.current.Data + directoryPercWritesFromNSPI.current.Data +
97 + directoryPercWritesFromNTDSAPI.current.Data +
98 + directoryPercWritesFromSAM.current.Data + directoryPercWritesOther.current.Data;
99 +
100 + collected_number searchValue =
101 + directoryPercSearchesFromDCA.current.Data + directoryPercSearchesFromKCC.current.Data +
102 + directoryPercSearchesFromLSA.current.Data + directoryPercSearchesFromNSPI.current.Data +
103 + directoryPercSearchesFromNTDSAPI.current.Data + directoryPercSearchesFromSAM.current.Data +
104 + directoryPercSearchesOther.current.Data;
105 +
106 + rrddim_set_by_pointer(st_directory_operation_total, rd_directory_operation_total_read, readValue);
107 +
108 + rrddim_set_by_pointer(st_directory_operation_total, rd_directory_operation_total_write, writeValue);
109 +
110 + rrddim_set_by_pointer(st_directory_operation_total, rd_directory_operation_total_search, searchValue);
111
112 rrdset_done(st_directory_operation_total);
113 }
114
139 -static void netdata_ad_cache_lookups(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
140 - static COUNTER_DATA nameCacheLookupsTotal = { .key = "DS Name Cache hit rate,secondvalue" };
115 +static void netdata_ad_cache_lookups(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
116 +{
117 + static COUNTER_DATA nameCacheLookupsTotal = {.key = "DS Name Cache hit rate,secondvalue"};
118
119 static RRDSET *st_name_cache_lookups_total = NULL;
120 static RRDDIM *rd_name_cache_lookups_total = NULL;
121
145 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &nameCacheLookupsTotal)) {
122 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &nameCacheLookupsTotal)) {
123 if (unlikely(!st_name_cache_lookups_total)) {
147 - st_name_cache_lookups_total = rrdset_create_localhost("ad"
148 - , "name_cache_lookups"
149 - , NULL
150 - , "database"
151 - , "ad.name_cache_lookups"
152 - , "Name cache lookups"
153 - , "lookups/s"
154 - , PLUGIN_WINDOWS_NAME
155 - , "PerflibAD"
156 - , PRIO_AD_CACHE_LOOKUP_TOTAL
157 - , update_every
158 - , RRDSET_TYPE_LINE
159 - );
160 -
161 - rd_name_cache_lookups_total = rrddim_add(st_name_cache_lookups_total,
162 - "lookups",
163 - NULL,
164 - 1,
165 - 1,
166 - RRD_ALGORITHM_INCREMENTAL);
124 + st_name_cache_lookups_total = rrdset_create_localhost(
125 + "ad",
126 + "name_cache_lookups",
127 + NULL,
128 + "database",
129 + "ad.name_cache_lookups",
130 + "Name cache lookups",
131 + "lookups/s",
132 + PLUGIN_WINDOWS_NAME,
133 + "PerflibAD",
134 + PRIO_AD_CACHE_LOOKUP_TOTAL,
135 + update_every,
136 + RRDSET_TYPE_LINE);
137 +
138 + rd_name_cache_lookups_total =
139 + rrddim_add(st_name_cache_lookups_total, "lookups", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
140 }
141
169 - rrddim_set_by_pointer(st_name_cache_lookups_total,
170 - rd_name_cache_lookups_total,
171 - (collected_number)nameCacheLookupsTotal.current.Data);
142 + rrddim_set_by_pointer(
143 + st_name_cache_lookups_total,
144 + rd_name_cache_lookups_total,
145 + (collected_number)nameCacheLookupsTotal.current.Data);
146 rrdset_done(st_name_cache_lookups_total);
147 }
148 }
149
176 -static void netdata_ad_cache_hits(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
177 - static COUNTER_DATA nameCacheHitsTotal = { .key = "DS Name Cache hit rate" };
150 +static void netdata_ad_cache_hits(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
151 +{
152 + static COUNTER_DATA nameCacheHitsTotal = {.key = "DS Name Cache hit rate"};
153
154 static RRDSET *st_name_cache_hits_total = NULL;
155 static RRDDIM *rd_name_cache_hits_total = NULL;
156
182 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &nameCacheHitsTotal)) {
157 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &nameCacheHitsTotal)) {
158 if (unlikely(!st_name_cache_hits_total)) {
184 - st_name_cache_hits_total = rrdset_create_localhost("ad"
185 - , "name_cache_hits"
186 - , NULL
187 - , "database"
188 - , "ad.name_cache_hits"
189 - , "Name cache hits"
190 - , "hits/s"
191 - , PLUGIN_WINDOWS_NAME
192 - , "PerflibAD"
193 - , PRIO_AD_CACHE_HITS_TOTAL
194 - , update_every
195 - , RRDSET_TYPE_LINE
196 - );
197 -
198 - rd_name_cache_hits_total = rrddim_add(st_name_cache_hits_total,
199 - "hits",
200 - NULL,
201 - 1,
202 - 1,
203 - RRD_ALGORITHM_INCREMENTAL);
159 + st_name_cache_hits_total = rrdset_create_localhost(
160 + "ad",
161 + "name_cache_hits",
162 + NULL,
163 + "database",
164 + "ad.name_cache_hits",
165 + "Name cache hits",
166 + "hits/s",
167 + PLUGIN_WINDOWS_NAME,
168 + "PerflibAD",
169 + PRIO_AD_CACHE_HITS_TOTAL,
170 + update_every,
171 + RRDSET_TYPE_LINE);
172 +
173 + rd_name_cache_hits_total =
174 + rrddim_add(st_name_cache_hits_total, "hits", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
175 }
176
206 - rrddim_set_by_pointer(st_name_cache_hits_total,
207 - rd_name_cache_hits_total,
208 - (collected_number)nameCacheHitsTotal.current.Data);
177 + rrddim_set_by_pointer(
178 + st_name_cache_hits_total, rd_name_cache_hits_total, (collected_number)nameCacheHitsTotal.current.Data);
179 rrdset_done(st_name_cache_hits_total);
180 }
181 }
182
213 -static void netdata_ad_searches(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
214 - static COUNTER_DATA ldapSearchesTotal = { .key = "LDAP Searches/sec" };
183 +static void netdata_ad_searches(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
184 +{
185 + static COUNTER_DATA ldapSearchesTotal = {.key = "LDAP Searches/sec"};
186
187 static RRDSET *st_ldap_searches_total = NULL;
188 static RRDDIM *rd_ldap_searches_total = NULL;
189
219 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &ldapSearchesTotal)) {
190 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &ldapSearchesTotal)) {
191 if (unlikely(!st_ldap_searches_total)) {
221 - st_ldap_searches_total = rrdset_create_localhost("ad"
222 - , "ldap_searches"
223 - , NULL
224 - , "ldap"
225 - , "ad.ldap_searches"
226 - , "LDAP client search operations"
227 - , "searches/s"
228 - , PLUGIN_WINDOWS_NAME
229 - , "PerflibAD"
230 - , PRIO_AD_LDAP_SEARCHES_TOTAL
231 - , update_every
232 - , RRDSET_TYPE_LINE
233 - );
234 -
235 - rd_ldap_searches_total = rrddim_add(st_ldap_searches_total,
236 - "searches",
237 - NULL,
238 - 1,
239 - 1,
240 - RRD_ALGORITHM_INCREMENTAL);
192 + st_ldap_searches_total = rrdset_create_localhost(
193 + "ad",
194 + "ldap_searches",
195 + NULL,
196 + "ldap",
197 + "ad.ldap_searches",
198 + "LDAP client search operations",
199 + "searches/s",
200 + PLUGIN_WINDOWS_NAME,
201 + "PerflibAD",
202 + PRIO_AD_LDAP_SEARCHES_TOTAL,
203 + update_every,
204 + RRDSET_TYPE_LINE);
205 +
206 + rd_ldap_searches_total =
207 + rrddim_add(st_ldap_searches_total, "searches", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
208 }
209
243 - rrddim_set_by_pointer(st_ldap_searches_total,
244 - rd_ldap_searches_total,
245 - (collected_number)ldapSearchesTotal.current.Data);
210 + rrddim_set_by_pointer(
211 + st_ldap_searches_total, rd_ldap_searches_total, (collected_number)ldapSearchesTotal.current.Data);
212 rrdset_done(st_ldap_searches_total);
213 }
214 }
215
250 -static void netdata_ad_properties(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
251 - static COUNTER_DATA replicationInboundPropertiesUpdatedTotal = { .key = "DRA Inbound Properties Applied/sec" };
252 - static COUNTER_DATA replicationInboundPropertiesFilteredTotal = { .key = "DRA Inbound Properties Filtered/sec" };
216 +static void netdata_ad_properties(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
217 +{
218 + static COUNTER_DATA replicationInboundPropertiesUpdatedTotal = {.key = "DRA Inbound Properties Applied/sec"};
219 + static COUNTER_DATA replicationInboundPropertiesFilteredTotal = {.key = "DRA Inbound Properties Filtered/sec"};
220
221 static RRDSET *st_dra_replication_properties_updated = NULL;
222 static RRDDIM *rd_dra_replication_properties_updated = NULL;
@@ -261,30 +228,28 @@ static void netdata_ad_properties(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE
228 }
229
230 if (unlikely(!st_dra_replication_properties_updated)) {
264 - st_dra_replication_properties_updated = rrdset_create_localhost("ad"
265 - , "dra_replication_properties_updated"
266 - , NULL
267 - , "replication"
268 - , "ad.dra_replication_properties_updated"
269 - , "DRA replication properties updated"
270 - , "properties/s"
271 - , PLUGIN_WINDOWS_NAME
272 - , "PerflibAD"
273 - , PRIO_AD_REPLICATION_PROPERTY_UPDATED
274 - , update_every
275 - , RRDSET_TYPE_LINE);
276 -
277 - rd_dra_replication_properties_updated = rrddim_add(st_dra_replication_properties_updated,
278 - "inbound",
279 - NULL,
280 - 1,
281 - 1,
282 - RRD_ALGORITHM_INCREMENTAL);
231 + st_dra_replication_properties_updated = rrdset_create_localhost(
232 + "ad",
233 + "dra_replication_properties_updated",
234 + NULL,
235 + "replication",
236 + "ad.dra_replication_properties_updated",
237 + "DRA replication properties updated",
238 + "properties/s",
239 + PLUGIN_WINDOWS_NAME,
240 + "PerflibAD",
241 + PRIO_AD_REPLICATION_PROPERTY_UPDATED,
242 + update_every,
243 + RRDSET_TYPE_LINE);
244 +
245 + rd_dra_replication_properties_updated =
246 + rrddim_add(st_dra_replication_properties_updated, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
247 }
248
285 - rrddim_set_by_pointer(st_dra_replication_properties_updated,
286 - rd_dra_replication_properties_updated,
287 - (collected_number)replicationInboundPropertiesUpdatedTotal.current.Data);
249 + rrddim_set_by_pointer(
250 + st_dra_replication_properties_updated,
251 + rd_dra_replication_properties_updated,
252 + (collected_number)replicationInboundPropertiesUpdatedTotal.current.Data);
253 rrdset_done(st_dra_replication_properties_updated);
254
255 totalPropertyChart:
@@ -293,39 +258,42 @@ totalPropertyChart:
258 }
259
260 if (unlikely(!st_dra_replication_properties_filtered)) {
296 - st_dra_replication_properties_filtered = rrdset_create_localhost("ad"
297 - , "dra_replication_properties_filtered"
298 - , NULL
299 - , "replication"
300 - , "ad.dra_replication_properties_filtered"
301 - , "DRA replication properties filtered"
302 - , "properties/s"
303 - , PLUGIN_WINDOWS_NAME
304 - , "PerflibAD"
305 - , PRIO_AD_REPLICATION_PROPERTY_FILTERED
306 - , update_every
307 - , RRDSET_TYPE_LINE);
308 -
309 - rd_dra_replication_properties_filtered = rrddim_add(st_dra_replication_properties_filtered,
310 - "inbound",
311 - NULL,
312 - 1,
313 - 1,
314 - RRD_ALGORITHM_INCREMENTAL);
261 + st_dra_replication_properties_filtered = rrdset_create_localhost(
262 + "ad",
263 + "dra_replication_properties_filtered",
264 + NULL,
265 + "replication",
266 + "ad.dra_replication_properties_filtered",
267 + "DRA replication properties filtered",
268 + "properties/s",
269 + PLUGIN_WINDOWS_NAME,
270 + "PerflibAD",
271 + PRIO_AD_REPLICATION_PROPERTY_FILTERED,
272 + update_every,
273 + RRDSET_TYPE_LINE);
274 +
275 + rd_dra_replication_properties_filtered =
276 + rrddim_add(st_dra_replication_properties_filtered, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
277 }
278
317 - rrddim_set_by_pointer(st_dra_replication_properties_filtered,
318 - rd_dra_replication_properties_filtered,
319 - (collected_number)replicationInboundPropertiesFilteredTotal.current.Data);
279 + rrddim_set_by_pointer(
280 + st_dra_replication_properties_filtered,
281 + rd_dra_replication_properties_filtered,
282 + (collected_number)replicationInboundPropertiesFilteredTotal.current.Data);
283 rrdset_done(st_dra_replication_properties_filtered);
284 }
285
323 -static void netdata_ad_compressed_traffic(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
324 - static COUNTER_DATA replicationInboundDataInterSiteBytesTotal = { .key = "DRA Inbound Bytes Compressed (Between Sites, After Compression)/sec" };
325 - static COUNTER_DATA replicationOutboundDataInterSiteBytesTotal = { .key = "DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec" };
286 +static void netdata_ad_compressed_traffic(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
287 +{
288 + static COUNTER_DATA replicationInboundDataInterSiteBytesTotal = {
289 + .key = "DRA Inbound Bytes Compressed (Between Sites, After Compression)/sec"};
290 + static COUNTER_DATA replicationOutboundDataInterSiteBytesTotal = {
291 + .key = "DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec"};
292
327 - static COUNTER_DATA replicationDataInboundIntraSiteBytesTotal = { .key = "DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec"};
328 - static COUNTER_DATA replicationDataOutboundIntraSiteBytesTotal = { .key = "DRA Outbound Bytes Not Compressed (Within Site)/sec"};
293 + static COUNTER_DATA replicationDataInboundIntraSiteBytesTotal = {
294 + .key = "DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec"};
295 + static COUNTER_DATA replicationDataOutboundIntraSiteBytesTotal = {
296 + .key = "DRA Outbound Bytes Not Compressed (Within Site)/sec"};
297
298 static RRDSET *st_dra_replication_intersite_compressed_traffic = NULL;
299 static RRDDIM *rd_replication_data_intersite_bytes_total_inbound = NULL;
@@ -341,40 +309,35 @@ static void netdata_ad_compressed_traffic(PERF_DATA_BLOCK *pDataBlock, PERF_OBJE
309 }
310
311 if (unlikely(!st_dra_replication_intersite_compressed_traffic)) {
344 - st_dra_replication_intersite_compressed_traffic = rrdset_create_localhost("ad"
345 - , "dra_replication_intersite_compressed_traffic"
346 - , NULL
347 - , "replication"
348 - , "ad.dra_replication_intersite_compressed_traffic"
349 - , "DRA replication compressed traffic withing site"
350 - , "bytes/s"
351 - , PLUGIN_WINDOWS_NAME
352 - , "PerflibAD"
353 - , PRIO_AD_REPLICATION_INTERSITE_COMPRESSED
354 - , update_every
355 - , RRDSET_TYPE_AREA);
356 -
357 - rd_replication_data_intersite_bytes_total_inbound = rrddim_add(st_dra_replication_intersite_compressed_traffic,
358 - "inbound",
359 - NULL,
360 - 1,
361 - 1,
362 - RRD_ALGORITHM_INCREMENTAL);
363 -
364 - rd_replication_data_intersite_bytes_total_outbound = rrddim_add(st_dra_replication_intersite_compressed_traffic,
365 - "outbound",
366 - NULL,
367 - -1,
368 - 1,
369 - RRD_ALGORITHM_INCREMENTAL);
312 + st_dra_replication_intersite_compressed_traffic = rrdset_create_localhost(
313 + "ad",
314 + "dra_replication_intersite_compressed_traffic",
315 + NULL,
316 + "replication",
317 + "ad.dra_replication_intersite_compressed_traffic",
318 + "DRA replication compressed traffic withing site",
319 + "bytes/s",
320 + PLUGIN_WINDOWS_NAME,
321 + "PerflibAD",
322 + PRIO_AD_REPLICATION_INTERSITE_COMPRESSED,
323 + update_every,
324 + RRDSET_TYPE_AREA);
325 +
326 + rd_replication_data_intersite_bytes_total_inbound = rrddim_add(
327 + st_dra_replication_intersite_compressed_traffic, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
328 +
329 + rd_replication_data_intersite_bytes_total_outbound = rrddim_add(
330 + st_dra_replication_intersite_compressed_traffic, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
331 }
332
372 - rrddim_set_by_pointer(st_dra_replication_intersite_compressed_traffic,
373 - rd_replication_data_intersite_bytes_total_inbound,
374 - (collected_number)replicationInboundDataInterSiteBytesTotal.current.Data);
375 - rrddim_set_by_pointer(st_dra_replication_intersite_compressed_traffic,
376 - rd_replication_data_intersite_bytes_total_outbound,
377 - (collected_number)replicationOutboundDataInterSiteBytesTotal.current.Data);
333 + rrddim_set_by_pointer(
334 + st_dra_replication_intersite_compressed_traffic,
335 + rd_replication_data_intersite_bytes_total_inbound,
336 + (collected_number)replicationInboundDataInterSiteBytesTotal.current.Data);
337 + rrddim_set_by_pointer(
338 + st_dra_replication_intersite_compressed_traffic,
339 + rd_replication_data_intersite_bytes_total_outbound,
340 + (collected_number)replicationOutboundDataInterSiteBytesTotal.current.Data);
341 rrdset_done(st_dra_replication_intersite_compressed_traffic);
342
343 intraChart:
@@ -384,47 +347,43 @@ intraChart:
347 }
348
349 if (unlikely(!st_dra_replication_intrasite_compressed_traffic)) {
387 - st_dra_replication_intrasite_compressed_traffic = rrdset_create_localhost("ad"
388 - , "dra_replication_intrasite_compressed_traffic"
389 - , NULL
390 - , "replication"
391 - , "ad.dra_replication_intrasite_compressed_traffic"
392 - , "DRA replication compressed traffic between sites"
393 - , "bytes/s"
394 - , PLUGIN_WINDOWS_NAME
395 - , "PerflibAD"
396 - , PRIO_AD_REPLICATION_INTRASITE_COMPRESSED
397 - , update_every
398 - , RRDSET_TYPE_LINE);
399 -
400 - rd_replication_data_intrasite_bytes_total_inbound = rrddim_add(st_dra_replication_intrasite_compressed_traffic,
401 - "inbound",
402 - NULL,
403 - 1,
404 - 1,
405 - RRD_ALGORITHM_INCREMENTAL);
406 -
407 - rd_replication_data_intrasite_bytes_total_outbound = rrddim_add(st_dra_replication_intrasite_compressed_traffic,
408 - "outbound",
409 - NULL,
410 - -1,
411 - 1,
412 - RRD_ALGORITHM_INCREMENTAL);
350 + st_dra_replication_intrasite_compressed_traffic = rrdset_create_localhost(
351 + "ad",
352 + "dra_replication_intrasite_compressed_traffic",
353 + NULL,
354 + "replication",
355 + "ad.dra_replication_intrasite_compressed_traffic",
356 + "DRA replication compressed traffic between sites",
357 + "bytes/s",
358 + PLUGIN_WINDOWS_NAME,
359 + "PerflibAD",
360 + PRIO_AD_REPLICATION_INTRASITE_COMPRESSED,
361 + update_every,
362 + RRDSET_TYPE_LINE);
363 +
364 + rd_replication_data_intrasite_bytes_total_inbound = rrddim_add(
365 + st_dra_replication_intrasite_compressed_traffic, "inbound", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
366 +
367 + rd_replication_data_intrasite_bytes_total_outbound = rrddim_add(
368 + st_dra_replication_intrasite_compressed_traffic, "outbound", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
369 }
370
415 - rrddim_set_by_pointer(st_dra_replication_intrasite_compressed_traffic,
416 - rd_replication_data_intrasite_bytes_total_inbound,
417 - (collected_number)replicationDataInboundIntraSiteBytesTotal.current.Data);
418 - rrddim_set_by_pointer(st_dra_replication_intrasite_compressed_traffic,
419 - rd_replication_data_intrasite_bytes_total_outbound,
420 - (collected_number)replicationDataOutboundIntraSiteBytesTotal.current.Data);
371 + rrddim_set_by_pointer(
372 + st_dra_replication_intrasite_compressed_traffic,
373 + rd_replication_data_intrasite_bytes_total_inbound,
374 + (collected_number)replicationDataInboundIntraSiteBytesTotal.current.Data);
375 + rrddim_set_by_pointer(
376 + st_dra_replication_intrasite_compressed_traffic,
377 + rd_replication_data_intrasite_bytes_total_outbound,
378 + (collected_number)replicationDataOutboundIntraSiteBytesTotal.current.Data);
379 rrdset_done(st_dra_replication_intrasite_compressed_traffic);
380 }
381
424 -static void netdata_ad_sync(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
425 - static COUNTER_DATA replicationSyncPending = { .key = "DRA Pending Replication Synchronizations" };
426 - static COUNTER_DATA replicationSyncRequestsTotal = { .key = "DRA Sync Requests Made" };
427 - static COUNTER_DATA replicationPendingSyncs = { .key = "DRA Pending Replication Synchronizations" };
382 +static void netdata_ad_sync(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
383 +{
384 + static COUNTER_DATA replicationSyncPending = {.key = "DRA Pending Replication Synchronizations"};
385 + static COUNTER_DATA replicationSyncRequestsTotal = {.key = "DRA Sync Requests Made"};
386 + static COUNTER_DATA replicationPendingSyncs = {.key = "DRA Pending Replication Synchronizations"};
387
388 static RRDSET *st_dra_replication_pending_syncs = NULL;
389 static RRDDIM *rd_dra_replication_pending_syncs = NULL;
@@ -438,30 +397,28 @@ static void netdata_ad_sync(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObje
397 }
398
399 if (unlikely(!st_dra_replication_pending_syncs)) {
441 - st_dra_replication_pending_syncs = rrdset_create_localhost("ad"
442 - , "dra_replication_pending_syncs"
443 - , NULL
444 - , "replication"
445 - , "ad.dra_replication_pending_syncs"
446 - , "DRA replication pending syncs"
447 - , "syncs"
448 - , PLUGIN_WINDOWS_NAME
449 - , "PerflibAD"
450 - , PRIO_AD_SYNC_PENDING
451 - , update_every
452 - , RRDSET_TYPE_LINE);
453 -
454 - rd_dra_replication_pending_syncs = rrddim_add(st_dra_replication_pending_syncs,
455 - "pending",
456 - NULL,
457 - 1,
458 - 1,
459 - RRD_ALGORITHM_ABSOLUTE);
400 + st_dra_replication_pending_syncs = rrdset_create_localhost(
401 + "ad",
402 + "dra_replication_pending_syncs",
403 + NULL,
404 + "replication",
405 + "ad.dra_replication_pending_syncs",
406 + "DRA replication pending syncs",
407 + "syncs",
408 + PLUGIN_WINDOWS_NAME,
409 + "PerflibAD",
410 + PRIO_AD_SYNC_PENDING,
411 + update_every,
412 + RRDSET_TYPE_LINE);
413 +
414 + rd_dra_replication_pending_syncs =
415 + rrddim_add(st_dra_replication_pending_syncs, "pending", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
416 }
417
462 - rrddim_set_by_pointer(st_dra_replication_pending_syncs,
463 - rd_dra_replication_pending_syncs,
464 - (collected_number)replicationSyncPending.current.Data);
418 + rrddim_set_by_pointer(
419 + st_dra_replication_pending_syncs,
420 + rd_dra_replication_pending_syncs,
421 + (collected_number)replicationSyncPending.current.Data);
422 rrdset_done(st_dra_replication_pending_syncs);
423
424 totalSyncChart:
@@ -470,30 +427,28 @@ totalSyncChart:
427 }
428
429 if (unlikely(!st_dra_replication_sync_requests)) {
473 - st_dra_replication_sync_requests = rrdset_create_localhost("ad"
474 - , "dra_replication_sync_requests"
475 - , NULL
476 - , "replication"
477 - , "ad.dra_replication_sync_requests"
478 - , "DRA replication sync requests"
479 - , "requests/s"
480 - , PLUGIN_WINDOWS_NAME
481 - , "PerflibAD"
482 - , PRIO_AD_SYNC_TOTAL
483 - , update_every
484 - , RRDSET_TYPE_LINE);
485 -
486 - rd_dra_replication_sync_requests = rrddim_add(st_dra_replication_sync_requests,
487 - "request",
488 - NULL,
489 - 1,
490 - 1,
491 - RRD_ALGORITHM_INCREMENTAL);
430 + st_dra_replication_sync_requests = rrdset_create_localhost(
431 + "ad",
432 + "dra_replication_sync_requests",
433 + NULL,
434 + "replication",
435 + "ad.dra_replication_sync_requests",
436 + "DRA replication sync requests",
437 + "requests/s",
438 + PLUGIN_WINDOWS_NAME,
439 + "PerflibAD",
440 + PRIO_AD_SYNC_TOTAL,
441 + update_every,
442 + RRDSET_TYPE_LINE);
443 +
444 + rd_dra_replication_sync_requests =
445 + rrddim_add(st_dra_replication_sync_requests, "request", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
446 }
447
494 - rrddim_set_by_pointer(st_dra_replication_sync_requests,
495 - rd_dra_replication_sync_requests,
496 - (collected_number)replicationSyncRequestsTotal.current.Data);
448 + rrddim_set_by_pointer(
449 + st_dra_replication_sync_requests,
450 + rd_dra_replication_sync_requests,
451 + (collected_number)replicationSyncRequestsTotal.current.Data);
452 rrdset_done(st_dra_replication_sync_requests);
453
454 RemainingSyncChart:
@@ -502,141 +457,131 @@ RemainingSyncChart:
457 }
458
459 if (unlikely(!st_dra_replication_sync_objects_remaining)) {
505 - st_dra_replication_sync_objects_remaining = rrdset_create_localhost("ad"
506 - , "dra_replication_sync_objects_remaining"
507 - , NULL
508 - , "replication"
509 - , "ad.dra_replication_sync_objects_remaining"
510 - , "DRA replication full sync objects remaining"
511 - , "objects"
512 - , PLUGIN_WINDOWS_NAME
513 - , "PerflibAD"
514 - , PRIO_AD_SYNC_OBJECTS_REMAINING
515 - , update_every
516 - , RRDSET_TYPE_LINE);
517 -
518 - rd_dra_replication_sync_objects_remaining = rrddim_add(st_dra_replication_sync_objects_remaining,
519 - "request",
520 - NULL,
521 - 1,
522 - 1,
523 - RRD_ALGORITHM_INCREMENTAL);
460 + st_dra_replication_sync_objects_remaining = rrdset_create_localhost(
461 + "ad",
462 + "dra_replication_sync_objects_remaining",
463 + NULL,
464 + "replication",
465 + "ad.dra_replication_sync_objects_remaining",
466 + "DRA replication full sync objects remaining",
467 + "objects",
468 + PLUGIN_WINDOWS_NAME,
469 + "PerflibAD",
470 + PRIO_AD_SYNC_OBJECTS_REMAINING,
471 + update_every,
472 + RRDSET_TYPE_LINE);
473 +
474 + rd_dra_replication_sync_objects_remaining =
475 + rrddim_add(st_dra_replication_sync_objects_remaining, "request", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
476 }
477
526 - rrddim_set_by_pointer(st_dra_replication_sync_objects_remaining,
527 - rd_dra_replication_sync_objects_remaining,
528 - (collected_number)replicationPendingSyncs.current.Data);
478 + rrddim_set_by_pointer(
479 + st_dra_replication_sync_objects_remaining,
480 + rd_dra_replication_sync_objects_remaining,
481 + (collected_number)replicationPendingSyncs.current.Data);
482 rrdset_done(st_dra_replication_sync_objects_remaining);
483 }
484
532 -static void netdata_ad_service_threads_in_use(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
533 - static COUNTER_DATA directoryServiceThreads = { .key = "DS Threads in Use" };
485 +static void
486 +netdata_ad_service_threads_in_use(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
487 +{
488 + static COUNTER_DATA directoryServiceThreads = {.key = "DS Threads in Use"};
489
490 static RRDSET *st_directory_services_threads = NULL;
491 static RRDDIM *rd_directory_services_threads = NULL;
492
538 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &directoryServiceThreads)) {
493 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &directoryServiceThreads)) {
494 if (unlikely(!st_directory_services_threads)) {
540 - st_directory_services_threads = rrdset_create_localhost("ad"
541 - , "ds_threads"
542 - , NULL
543 - , "threads"
544 - , "ad.ds_threads"
545 - , "Directory Service threads"
546 - , "threads"
547 - , PLUGIN_WINDOWS_NAME
548 - , "PerflibAD"
549 - , PRIO_AD_THREADS_IN_USE
550 - , update_every
551 - , RRDSET_TYPE_LINE
552 - );
553 -
554 - rd_directory_services_threads = rrddim_add(st_directory_services_threads,
555 - "in_use",
556 - NULL,
557 - 1,
558 - 1,
559 - RRD_ALGORITHM_ABSOLUTE);
495 + st_directory_services_threads = rrdset_create_localhost(
496 + "ad",
497 + "ds_threads",
498 + NULL,
499 + "threads",
500 + "ad.ds_threads",
501 + "Directory Service threads",
502 + "threads",
503 + PLUGIN_WINDOWS_NAME,
504 + "PerflibAD",
505 + PRIO_AD_THREADS_IN_USE,
506 + update_every,
507 + RRDSET_TYPE_LINE);
508 +
509 + rd_directory_services_threads =
510 + rrddim_add(st_directory_services_threads, "in_use", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
511 }
512
562 - rrddim_set_by_pointer(st_directory_services_threads,
563 - rd_directory_services_threads,
564 - (collected_number)directoryServiceThreads.current.Data);
513 + rrddim_set_by_pointer(
514 + st_directory_services_threads,
515 + rd_directory_services_threads,
516 + (collected_number)directoryServiceThreads.current.Data);
517 rrdset_done(st_directory_services_threads);
518 }
519 }
520
569 -static void netdata_ad_bind(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
570 - static COUNTER_DATA ldapLastBindTimeSecondsTotal = { .key = "DAP Bind Time" };
571 - static COUNTER_DATA bindsTotal = { .key = "DS Server Binds/sec" };
521 +static void netdata_ad_bind(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
522 +{
523 + static COUNTER_DATA ldapLastBindTimeSecondsTotal = {.key = "DAP Bind Time"};
524 + static COUNTER_DATA bindsTotal = {.key = "DS Server Binds/sec"};
525
526 static RRDSET *st_ldap_last_bind_time_seconds_total = NULL;
527 static RRDDIM *rd_ldap_last_bind_time_seconds_total = NULL;
528 static RRDSET *st_binds_total = NULL;
529 static RRDDIM *rd_binds_total = NULL;
530
578 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &ldapLastBindTimeSecondsTotal)) {
531 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &ldapLastBindTimeSecondsTotal)) {
532 if (unlikely(!st_ldap_last_bind_time_seconds_total)) {
580 - st_ldap_last_bind_time_seconds_total = rrdset_create_localhost("ad"
581 - , "ldap_last_bind_time"
582 - , NULL
583 - , "bind"
584 - , "ad.ldap_last_bind_time"
585 - , "LDAP last successful bind time"
586 - , "seconds"
587 - , PLUGIN_WINDOWS_NAME
588 - , "PerflibAD"
589 - , PRIO_AD_BIND_TIME
590 - , update_every
591 - , RRDSET_TYPE_LINE
592 - );
593 -
594 - rd_ldap_last_bind_time_seconds_total = rrddim_add(st_ldap_last_bind_time_seconds_total,
595 - "last_bind",
596 - NULL,
597 - 1,
598 - 1,
599 - RRD_ALGORITHM_ABSOLUTE);
533 + st_ldap_last_bind_time_seconds_total = rrdset_create_localhost(
534 + "ad",
535 + "ldap_last_bind_time",
536 + NULL,
537 + "bind",
538 + "ad.ldap_last_bind_time",
539 + "LDAP last successful bind time",
540 + "seconds",
541 + PLUGIN_WINDOWS_NAME,
542 + "PerflibAD",
543 + PRIO_AD_BIND_TIME,
544 + update_every,
545 + RRDSET_TYPE_LINE);
546 +
547 + rd_ldap_last_bind_time_seconds_total =
548 + rrddim_add(st_ldap_last_bind_time_seconds_total, "last_bind", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
549 }
550
602 - rrddim_set_by_pointer(st_ldap_last_bind_time_seconds_total,
603 - rd_ldap_last_bind_time_seconds_total,
604 - (collected_number)ldapLastBindTimeSecondsTotal.current.Data);
551 + rrddim_set_by_pointer(
552 + st_ldap_last_bind_time_seconds_total,
553 + rd_ldap_last_bind_time_seconds_total,
554 + (collected_number)ldapLastBindTimeSecondsTotal.current.Data);
555 rrdset_done(st_ldap_last_bind_time_seconds_total);
556 }
557
608 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &bindsTotal)) {
558 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &bindsTotal)) {
559 if (unlikely(!st_binds_total)) {
610 - st_binds_total = rrdset_create_localhost("ad"
611 - , "binds"
612 - , NULL
613 - , "bind"
614 - , "ad.binds"
615 - , "Successful binds"
616 - , "bind/s"
617 - , PLUGIN_WINDOWS_NAME
618 - , "PerflibAD"
619 - , PRIO_AD_BIND_TOTAL
620 - , update_every
621 - , RRDSET_TYPE_LINE);
622 -
623 - rd_binds_total = rrddim_add(st_binds_total,
624 - "binds",
625 - NULL,
626 - 1,
627 - 1,
628 - RRD_ALGORITHM_INCREMENTAL);
560 + st_binds_total = rrdset_create_localhost(
561 + "ad",
562 + "binds",
563 + NULL,
564 + "bind",
565 + "ad.binds",
566 + "Successful binds",
567 + "bind/s",
568 + PLUGIN_WINDOWS_NAME,
569 + "PerflibAD",
570 + PRIO_AD_BIND_TOTAL,
571 + update_every,
572 + RRDSET_TYPE_LINE);
573 +
574 + rd_binds_total = rrddim_add(st_binds_total, "binds", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
575 }
576
631 - rrddim_set_by_pointer(st_binds_total,
632 - rd_binds_total,
633 - (collected_number)bindsTotal.current.Data);
577 + rrddim_set_by_pointer(st_binds_total, rd_binds_total, (collected_number)bindsTotal.current.Data);
578 rrdset_done(st_binds_total);
579 }
580 }
581
638 -static void netdata_ad_atq(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
639 - static COUNTER_DATA atqAverageRequestLatency = { .key = "ATQ Request Latency" };
582 +static void netdata_ad_atq(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
583 +{
584 + static COUNTER_DATA atqAverageRequestLatency = {.key = "ATQ Request Latency"};
585 //static COUNTER_DATA atqOutstandingRequests = { .key = "ATQ Outstanding Queued Requests" };
586
587 static RRDSET *st_atq_average_request_latency = NULL;
@@ -646,33 +591,30 @@ static void netdata_ad_atq(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjec
591 static RRDDIM *rd_atq_outstanding_requests = NULL;
592 */
593
649 - if(perflibGetObjectCounter(pDataBlock, pObjectType, &atqAverageRequestLatency)) {
594 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &atqAverageRequestLatency)) {
595 if (unlikely(!st_atq_average_request_latency)) {
651 - st_atq_average_request_latency = rrdset_create_localhost("ad"
652 - , "atq_average_request_latency"
653 - , NULL
654 - , "queue"
655 - , "ad.atq_average_request_latency"
656 - , "Average request processing time"
657 - , "seconds"
658 - , PLUGIN_WINDOWS_NAME
659 - , "PerflibAD"
660 - , PRIO_AD_AVG_REQUEST_LATENCY
661 - , update_every
662 - , RRDSET_TYPE_LINE
663 - );
664 -
665 - rd_atq_average_request_latency = rrddim_add(st_atq_average_request_latency,
666 - "time",
667 - NULL,
668 - 1,
669 - 1000,
670 - RRD_ALGORITHM_ABSOLUTE);
596 + st_atq_average_request_latency = rrdset_create_localhost(
597 + "ad",
598 + "atq_average_request_latency",
599 + NULL,
600 + "queue",
601 + "ad.atq_average_request_latency",
602 + "Average request processing time",
603 + "seconds",
604 + PLUGIN_WINDOWS_NAME,
605 + "PerflibAD",
606 + PRIO_AD_AVG_REQUEST_LATENCY,
607 + update_every,
608 + RRDSET_TYPE_LINE);
609 +
610 + rd_atq_average_request_latency =
611 + rrddim_add(st_atq_average_request_latency, "time", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
612 }
613
673 - rrddim_set_by_pointer(st_atq_average_request_latency,
674 - rd_atq_average_request_latency,
675 - (collected_number)atqAverageRequestLatency.current.Data);
614 + rrddim_set_by_pointer(
615 + st_atq_average_request_latency,
616 + rd_atq_average_request_latency,
617 + (collected_number)atqAverageRequestLatency.current.Data);
618 rrdset_done(st_atq_average_request_latency);
619 }
620
@@ -707,11 +649,12 @@ static void netdata_ad_atq(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjec
649 } */
650 }
651
710 -static void netdata_ad_op_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
711 - static COUNTER_DATA databaseAddsPerSec = { .key = "Database adds/sec" };
712 - static COUNTER_DATA databaseDeletesPerSec = { .key = "Database deletes/sec" };
713 - static COUNTER_DATA databaseModifiesPerSec = { .key = "Database modifys/sec" };
714 - static COUNTER_DATA databaseRecyclesPerSec = { .key = "Database recycles/sec" };
652 +static void netdata_ad_op_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
653 +{
654 + static COUNTER_DATA databaseAddsPerSec = {.key = "Database adds/sec"};
655 + static COUNTER_DATA databaseDeletesPerSec = {.key = "Database deletes/sec"};
656 + static COUNTER_DATA databaseModifiesPerSec = {.key = "Database modifys/sec"};
657 + static COUNTER_DATA databaseRecyclesPerSec = {.key = "Database recycles/sec"};
658
659 static RRDSET *st_database_operation_total = NULL;
660 static RRDDIM *rd_database_operation_total_add = NULL;
@@ -725,69 +668,58 @@ static void netdata_ad_op_total(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *p
668 perflibGetObjectCounter(pDataBlock, pObjectType, &databaseRecyclesPerSec);
669
670 if (unlikely(!st_database_operation_total)) {
728 - st_database_operation_total = rrdset_create_localhost("ad"
729 - , "database_operations"
730 - , NULL
731 - , "database"
732 - , "ad.database_operations"
733 - , "AD database operations"
734 - , "operations/s"
735 - , PLUGIN_WINDOWS_NAME
736 - , "PerflibAD"
737 - , PRIO_AD_OPERATIONS_TOTAL
738 - , update_every
739 - , RRDSET_TYPE_LINE);
740 -
741 - rd_database_operation_total_add = rrddim_add(st_database_operation_total,
742 - "add",
743 - NULL,
744 - 1,
745 - 1,
746 - RRD_ALGORITHM_INCREMENTAL);
747 -
748 - rd_database_operation_total_delete = rrddim_add(st_database_operation_total,
749 - "delete",
750 - NULL,
751 - 1,
752 - 1,
753 - RRD_ALGORITHM_INCREMENTAL);
754 -
755 - rd_database_operation_total_modify = rrddim_add(st_database_operation_total,
756 - "modify",
757 - NULL,
758 - 1,
759 - 1,
760 - RRD_ALGORITHM_INCREMENTAL);
761 -
762 - rd_database_operation_total_recycle = rrddim_add(st_database_operation_total,
763 - "recycle",
764 - NULL,
765 - 1,
766 - 1,
767 - RRD_ALGORITHM_INCREMENTAL);
671 + st_database_operation_total = rrdset_create_localhost(
672 + "ad",
673 + "database_operations",
674 + NULL,
675 + "database",
676 + "ad.database_operations",
677 + "AD database operations",
678 + "operations/s",
679 + PLUGIN_WINDOWS_NAME,
680 + "PerflibAD",
681 + PRIO_AD_OPERATIONS_TOTAL,
682 + update_every,
683 + RRDSET_TYPE_LINE);
684 +
685 + rd_database_operation_total_add =
686 + rrddim_add(st_database_operation_total, "add", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
687 +
688 + rd_database_operation_total_delete =
689 + rrddim_add(st_database_operation_total, "delete", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
690 +
691 + rd_database_operation_total_modify =
692 + rrddim_add(st_database_operation_total, "modify", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
693 +
694 + rd_database_operation_total_recycle =
695 + rrddim_add(st_database_operation_total, "recycle", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
696 }
697
770 - rrddim_set_by_pointer(st_database_operation_total,
771 - rd_database_operation_total_add,
772 - (collected_number)databaseAddsPerSec.current.Data);
698 + rrddim_set_by_pointer(
699 + st_database_operation_total,
700 + rd_database_operation_total_add,
701 + (collected_number)databaseAddsPerSec.current.Data);
702
774 - rrddim_set_by_pointer(st_database_operation_total,
775 - rd_database_operation_total_delete,
776 - (collected_number)databaseDeletesPerSec.current.Data);
703 + rrddim_set_by_pointer(
704 + st_database_operation_total,
705 + rd_database_operation_total_delete,
706 + (collected_number)databaseDeletesPerSec.current.Data);
707
778 - rrddim_set_by_pointer(st_database_operation_total,
779 - rd_database_operation_total_modify,
780 - (collected_number)databaseModifiesPerSec.current.Data);
708 + rrddim_set_by_pointer(
709 + st_database_operation_total,
710 + rd_database_operation_total_modify,
711 + (collected_number)databaseModifiesPerSec.current.Data);
712
782 - rrddim_set_by_pointer(st_database_operation_total,
783 - rd_database_operation_total_recycle,
784 - (collected_number)databaseRecyclesPerSec.current.Data);
713 + rrddim_set_by_pointer(
714 + st_database_operation_total,
715 + rd_database_operation_total_recycle,
716 + (collected_number)databaseRecyclesPerSec.current.Data);
717
718 rrdset_done(st_database_operation_total);
787 -
719 }
720
790 -static bool do_AD(PERF_DATA_BLOCK *pDataBlock, int update_every) {
721 +static bool do_AD(PERF_DATA_BLOCK *pDataBlock, int update_every)
722 +{
723 PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, "DirectoryServices");
724 if (!pObjectType)
725 return false;
@@ -806,8 +738,7 @@ static bool do_AD(PERF_DATA_BLOCK *pDataBlock, int update_every) {
738 netdata_ad_op_total,
739
740 // This must be the end
809 - NULL
810 - };
741 + NULL};
742
743 for (int i = 0; doAD[i]; i++)
744 doAD[i](pDataBlock, pObjectType, update_every);
@@ -815,20 +746,22 @@ static bool do_AD(PERF_DATA_BLOCK *pDataBlock, int update_every) {
746 return true;
747 }
748
818 -int do_PerflibAD(int update_every, usec_t dt __maybe_unused) {
749 +int do_PerflibAD(int update_every, usec_t dt __maybe_unused)
750 +{
751 static bool initialized = false;
752
821 - if(unlikely(!initialized)) {
753 + if (unlikely(!initialized)) {
754 initialize();
755 initialized = true;
756 }
757
758 DWORD id = RegistryFindIDByName("DirectoryServices");
827 - if(id == PERFLIB_REGISTRY_NAME_NOT_FOUND)
759 + if (id == PERFLIB_REGISTRY_NAME_NOT_FOUND)
760 return -1;
761
762 PERF_DATA_BLOCK *pDataBlock = perflibGetPerformanceData(id);
831 - if(!pDataBlock) return -1;
763 + if (!pDataBlock)
764 + return -1;
765
766 do_AD(pDataBlock, update_every);
767
src/collectors/windows.plugin/perflib-netframework.c
+376 -392
@@ -154,7 +154,8 @@ struct net_framework_instances {
154 COUNTER_DATA NETFrameworkCLRLocksAndThreadsContentions;
155 };
156
157 -static inline void initialize_net_framework_processes_keys(struct net_framework_instances *p) {
157 +static inline void initialize_net_framework_processes_keys(struct net_framework_instances *p)
158 +{
159 p->NETFrameworkCLRExceptionFilters.key = "# of Filters / sec";
160 p->NETFrameworkCLRExceptionFinallys.key = "# of Finallys / sec";
161 p->NETFrameworkCLRExceptionThrown.key = "# of Exceps Thrown / sec";
@@ -200,21 +201,25 @@ static inline void initialize_net_framework_processes_keys(struct net_framework_
201 void dict_net_framework_processes_insert_cb(
202 const DICTIONARY_ITEM *item __maybe_unused,
203 void *value,
203 - void *data __maybe_unused) {
204 + void *data __maybe_unused)
205 +{
206 struct net_framework_instances *p = value;
207 initialize_net_framework_processes_keys(p);
208 }
209
210 static DICTIONARY *processes = NULL;
211
210 -static void initialize(void) {
212 +static void initialize(void)
213 +{
214 processes = dictionary_create_advanced(
215 DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct net_framework_instances));
216
217 dictionary_register_insert_callback(processes, dict_net_framework_processes_insert_cb, NULL);
218 }
219
217 -static void netdata_framework_clr_exceptions(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
220 +static void
221 +netdata_framework_clr_exceptions(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
222 +{
223 PERF_INSTANCE_DEFINITION *pi = NULL;
224 char id[RRD_ID_LENGTH_MAX + 1];
225 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
@@ -363,7 +368,8 @@ static void netdata_framework_clr_exceptions(PERF_DATA_BLOCK *pDataBlock, PERF_O
368 }
369 }
370
366 -static void netdata_framework_clr_interop(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
371 +static void netdata_framework_clr_interop(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
372 +{
373 PERF_INSTANCE_DEFINITION *pi = NULL;
374 char id[RRD_ID_LENGTH_MAX + 1];
375 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
@@ -488,7 +494,8 @@ static void netdata_framework_clr_interop(PERF_DATA_BLOCK *pDataBlock, PERF_OBJE
494 }
495 }
496
491 -static void netdata_framework_clr_jit(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
497 +static void netdata_framework_clr_jit(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
498 +{
499 PERF_INSTANCE_DEFINITION *pi = NULL;
500 char id[RRD_ID_LENGTH_MAX + 1];
501 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
@@ -631,7 +638,8 @@ static void netdata_framework_clr_jit(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_T
638 }
639 }
640
634 -static void netdata_framework_clr_loading(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every) {
641 +static void netdata_framework_clr_loading(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
642 +{
643 char id[RRD_ID_LENGTH_MAX + 1];
644 PERF_INSTANCE_DEFINITION *pi = NULL;
645 for (LONG i = 0; i < pObjectType->NumInstances; i++) {
@@ -844,9 +852,7 @@ static void netdata_framework_clr_loading(PERF_DATA_BLOCK *pDataBlock, PERF_OBJE
852 }
853 }
854
847 -static void netdata_framework_clr_remoting(PERF_DATA_BLOCK *pDataBlock,
848 - PERF_OBJECT_TYPE *pObjectType,
849 - int update_every)
855 +static void netdata_framework_clr_remoting(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
856 {
857 char id[RRD_ID_LENGTH_MAX + 1];
858 PERF_INSTANCE_DEFINITION *pi = NULL;
@@ -867,223 +873,213 @@ static void netdata_framework_clr_remoting(PERF_DATA_BLOCK *pDataBlock,
873 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingChannels)) {
874 if (!p->st_clrremoting_channels) {
875 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrremoting_channels", windows_shared_buffer);
870 - p->st_clrremoting_channels = rrdset_create_localhost("netframework"
871 - , id, NULL
872 - , "remoting"
873 - , "netframework.clrremoting_channels"
874 - , "Registered channels"
875 - , "channels/s"
876 - , PLUGIN_WINDOWS_NAME
877 - , "PerflibNetFramework"
878 - , PRIO_NETFRAMEWORK_CLR_REMOTING_CHANNELS
879 - , update_every
880 - , RRDSET_TYPE_LINE
881 - );
876 + p->st_clrremoting_channels = rrdset_create_localhost(
877 + "netframework",
878 + id,
879 + NULL,
880 + "remoting",
881 + "netframework.clrremoting_channels",
882 + "Registered channels",
883 + "channels/s",
884 + PLUGIN_WINDOWS_NAME,
885 + "PerflibNetFramework",
886 + PRIO_NETFRAMEWORK_CLR_REMOTING_CHANNELS,
887 + update_every,
888 + RRDSET_TYPE_LINE);
889
890 snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_channels_total", windows_shared_buffer);
884 - p->rd_clrremoting_channels = rrddim_add(p->st_clrremoting_channels,
885 - id,
886 - "registered",
887 - 1,
888 - 1,
889 - RRD_ALGORITHM_INCREMENTAL);
890 -
891 - rrdlabels_add(p->st_clrremoting_channels->rrdlabels,
892 - "process",
893 - windows_shared_buffer,
894 - RRDLABEL_SRC_AUTO);
891 + p->rd_clrremoting_channels =
892 + rrddim_add(p->st_clrremoting_channels, id, "registered", 1, 1, RRD_ALGORITHM_INCREMENTAL);
893 +
894 + rrdlabels_add(
895 + p->st_clrremoting_channels->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
896 }
897
897 - rrddim_set_by_pointer(p->st_clrremoting_channels,
898 - p->rd_clrremoting_channels,
899 - (collected_number)p->NETFrameworkCLRRemotingChannels.current.Data);
898 + rrddim_set_by_pointer(
899 + p->st_clrremoting_channels,
900 + p->rd_clrremoting_channels,
901 + (collected_number)p->NETFrameworkCLRRemotingChannels.current.Data);
902 rrdset_done(p->st_clrremoting_channels);
903 }
904
905 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContextBoundClassesLoaded)) {
906 if (!p->st_clrremoting_context_bound_classes_loaded) {
907 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrremoting_context_bound_classes_loaded", windows_shared_buffer);
906 - p->st_clrremoting_context_bound_classes_loaded = rrdset_create_localhost("netframework"
907 - , id, NULL
908 - , "remoting"
909 - , "netframework.clrremoting_context_bound_classes_loaded"
910 - , "Loaded context-bound classes"
911 - , "classes"
912 - , PLUGIN_WINDOWS_NAME
913 - , "PerflibNetFramework"
914 - , PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXT_BOUND_CLASSES_LOADED
915 - , update_every
916 - , RRDSET_TYPE_LINE
917 - );
918 -
919 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_context_bound_classes_loaded", windows_shared_buffer);
920 - p->rd_clrremoting_context_bound_classes_loaded = rrddim_add(p->st_clrremoting_context_bound_classes_loaded,
921 - id,
922 - "loaded",
923 - 1,
924 - 1,
925 - RRD_ALGORITHM_ABSOLUTE);
926 -
927 - rrdlabels_add(p->st_clrremoting_context_bound_classes_loaded->rrdlabels,
928 - "process",
929 - windows_shared_buffer,
930 - RRDLABEL_SRC_AUTO);
908 + p->st_clrremoting_context_bound_classes_loaded = rrdset_create_localhost(
909 + "netframework",
910 + id,
911 + NULL,
912 + "remoting",
913 + "netframework.clrremoting_context_bound_classes_loaded",
914 + "Loaded context-bound classes",
915 + "classes",
916 + PLUGIN_WINDOWS_NAME,
917 + "PerflibNetFramework",
918 + PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXT_BOUND_CLASSES_LOADED,
919 + update_every,
920 + RRDSET_TYPE_LINE);
921 +
922 + snprintfz(
923 + id,
924 + RRD_ID_LENGTH_MAX,
925 + "netframework_%s_clrremoting_context_bound_classes_loaded",
926 + windows_shared_buffer);
927 + p->rd_clrremoting_context_bound_classes_loaded = rrddim_add(
928 + p->st_clrremoting_context_bound_classes_loaded, id, "loaded", 1, 1, RRD_ALGORITHM_ABSOLUTE);
929 +
930 + rrdlabels_add(
931 + p->st_clrremoting_context_bound_classes_loaded->rrdlabels,
932 + "process",
933 + windows_shared_buffer,
934 + RRDLABEL_SRC_AUTO);
935 }
936
933 - rrddim_set_by_pointer(p->st_clrremoting_context_bound_classes_loaded,
934 - p->rd_clrremoting_context_bound_classes_loaded,
935 - (collected_number)p->NETFrameworkCLRRemotingContextBoundClassesLoaded.current.Data);
937 + rrddim_set_by_pointer(
938 + p->st_clrremoting_context_bound_classes_loaded,
939 + p->rd_clrremoting_context_bound_classes_loaded,
940 + (collected_number)p->NETFrameworkCLRRemotingContextBoundClassesLoaded.current.Data);
941 rrdset_done(p->st_clrremoting_context_bound_classes_loaded);
942 }
943
944 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContextBoundObjects)) {
945 if (!p->st_clrremoting_context_bound_objects) {
946 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrremoting_context_bound_objects", windows_shared_buffer);
942 - p->st_clrremoting_context_bound_objects = rrdset_create_localhost("netframework"
943 - , id, NULL
944 - , "remoting"
945 - , "netframework.clrremoting_context_bound_objects"
946 - , "Allocated context-bound objects"
947 - , "objects/s"
948 - , PLUGIN_WINDOWS_NAME
949 - , "PerflibNetFramework"
950 - , PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXT_BOUND_OBJECTS
951 - , update_every
952 - , RRDSET_TYPE_LINE
953 - );
954 -
955 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_context_bound_objects_total", windows_shared_buffer);
956 - p->rd_clrremoting_context_bound_objects = rrddim_add(p->st_clrremoting_context_bound_objects,
957 - id,
958 - "allocated",
959 - 1,
960 - 1,
961 - RRD_ALGORITHM_INCREMENTAL);
962 -
963 - rrdlabels_add(p->st_clrremoting_context_bound_objects->rrdlabels,
964 - "process",
965 - windows_shared_buffer,
966 - RRDLABEL_SRC_AUTO);
947 + p->st_clrremoting_context_bound_objects = rrdset_create_localhost(
948 + "netframework",
949 + id,
950 + NULL,
951 + "remoting",
952 + "netframework.clrremoting_context_bound_objects",
953 + "Allocated context-bound objects",
954 + "objects/s",
955 + PLUGIN_WINDOWS_NAME,
956 + "PerflibNetFramework",
957 + PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXT_BOUND_OBJECTS,
958 + update_every,
959 + RRDSET_TYPE_LINE);
960 +
961 + snprintfz(
962 + id,
963 + RRD_ID_LENGTH_MAX,
964 + "netframework_%s_clrremoting_context_bound_objects_total",
965 + windows_shared_buffer);
966 + p->rd_clrremoting_context_bound_objects = rrddim_add(
967 + p->st_clrremoting_context_bound_objects, id, "allocated", 1, 1, RRD_ALGORITHM_INCREMENTAL);
968 +
969 + rrdlabels_add(
970 + p->st_clrremoting_context_bound_objects->rrdlabels,
971 + "process",
972 + windows_shared_buffer,
973 + RRDLABEL_SRC_AUTO);
974 }
975
969 - rrddim_set_by_pointer(p->st_clrremoting_context_bound_objects,
970 - p->rd_clrremoting_context_bound_objects,
971 - (collected_number)p->NETFrameworkCLRRemotingContextBoundObjects.current.Data);
976 + rrddim_set_by_pointer(
977 + p->st_clrremoting_context_bound_objects,
978 + p->rd_clrremoting_context_bound_objects,
979 + (collected_number)p->NETFrameworkCLRRemotingContextBoundObjects.current.Data);
980 rrdset_done(p->st_clrremoting_context_bound_objects);
981 }
982 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContextProxies)) {
983 if (!p->st_clrremoting_context_proxies) {
984 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrremoting_context_proxies", windows_shared_buffer);
977 - p->st_clrremoting_context_proxies = rrdset_create_localhost("netframework"
978 - , id, NULL
979 - , "remoting"
980 - , "netframework.clrremoting_context_proxies"
981 - , "Remoting proxy objects"
982 - , "objects/s"
983 - , PLUGIN_WINDOWS_NAME
984 - , "PerflibNetFramework"
985 - , PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXTS_PROXIES
986 - , update_every
987 - , RRDSET_TYPE_LINE
988 - );
989 -
990 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_context_proxies_total", windows_shared_buffer);
991 - p->rd_clrremoting_context_proxies = rrddim_add(p->st_clrremoting_context_proxies,
992 - id,
993 - "objects",
994 - 1,
995 - 1,
996 - RRD_ALGORITHM_INCREMENTAL);
997 -
998 - rrdlabels_add(p->st_clrremoting_context_proxies->rrdlabels,
999 - "process",
1000 - windows_shared_buffer,
1001 - RRDLABEL_SRC_AUTO);
985 + p->st_clrremoting_context_proxies = rrdset_create_localhost(
986 + "netframework",
987 + id,
988 + NULL,
989 + "remoting",
990 + "netframework.clrremoting_context_proxies",
991 + "Remoting proxy objects",
992 + "objects/s",
993 + PLUGIN_WINDOWS_NAME,
994 + "PerflibNetFramework",
995 + PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXTS_PROXIES,
996 + update_every,
997 + RRDSET_TYPE_LINE);
998 +
999 + snprintfz(
1000 + id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_context_proxies_total", windows_shared_buffer);
1001 + p->rd_clrremoting_context_proxies =
1002 + rrddim_add(p->st_clrremoting_context_proxies, id, "objects", 1, 1, RRD_ALGORITHM_INCREMENTAL);
1003 +
1004 + rrdlabels_add(
1005 + p->st_clrremoting_context_proxies->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1006 }
1007
1004 - rrddim_set_by_pointer(p->st_clrremoting_context_proxies,
1005 - p->rd_clrremoting_context_proxies,
1006 - (collected_number)p->NETFrameworkCLRRemotingContextProxies.current.Data);
1008 + rrddim_set_by_pointer(
1009 + p->st_clrremoting_context_proxies,
1010 + p->rd_clrremoting_context_proxies,
1011 + (collected_number)p->NETFrameworkCLRRemotingContextProxies.current.Data);
1012 rrdset_done(p->st_clrremoting_context_proxies);
1013 }
1014
1015 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContexts)) {
1016 if (!p->st_clrremoting_contexts) {
1017 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrremoting_contexts", windows_shared_buffer);
1013 - p->st_clrremoting_contexts = rrdset_create_localhost("netframework"
1014 - , id, NULL
1015 - , "remoting"
1016 - , "netframework.clrremoting_contexts"
1017 - , "Total of remoting contexts"
1018 - , "contexts"
1019 - , PLUGIN_WINDOWS_NAME
1020 - , "PerflibNetFramework"
1021 - , PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXTS
1022 - , update_every
1023 - , RRDSET_TYPE_LINE
1024 - );
1018 + p->st_clrremoting_contexts = rrdset_create_localhost(
1019 + "netframework",
1020 + id,
1021 + NULL,
1022 + "remoting",
1023 + "netframework.clrremoting_contexts",
1024 + "Total of remoting contexts",
1025 + "contexts",
1026 + PLUGIN_WINDOWS_NAME,
1027 + "PerflibNetFramework",
1028 + PRIO_NETFRAMEWORK_CLR_REMOTING_CONTEXTS,
1029 + update_every,
1030 + RRDSET_TYPE_LINE);
1031
1032 snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_contexts", windows_shared_buffer);
1027 - p->rd_clrremoting_contexts = rrddim_add(p->st_clrremoting_contexts,
1028 - id,
1029 - "contexts",
1030 - 1,
1031 - 1,
1032 - RRD_ALGORITHM_ABSOLUTE);
1033 -
1034 - rrdlabels_add(p->st_clrremoting_contexts->rrdlabels,
1035 - "process",
1036 - windows_shared_buffer,
1037 - RRDLABEL_SRC_AUTO);
1033 + p->rd_clrremoting_contexts =
1034 + rrddim_add(p->st_clrremoting_contexts, id, "contexts", 1, 1, RRD_ALGORITHM_ABSOLUTE);
1035 +
1036 + rrdlabels_add(
1037 + p->st_clrremoting_contexts->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1038 }
1039
1040 - rrddim_set_by_pointer(p->st_clrremoting_contexts,
1041 - p->rd_clrremoting_contexts,
1042 - (collected_number)p->NETFrameworkCLRRemotingContexts.current.Data);
1040 + rrddim_set_by_pointer(
1041 + p->st_clrremoting_contexts,
1042 + p->rd_clrremoting_contexts,
1043 + (collected_number)p->NETFrameworkCLRRemotingContexts.current.Data);
1044 rrdset_done(p->st_clrremoting_contexts);
1045 }
1046
1047 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingRemoteCalls)) {
1048 if (!p->st_clrremoting_remote_calls) {
1049 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrremoting_calls", windows_shared_buffer);
1049 - p->st_clrremoting_remote_calls = rrdset_create_localhost("netframework"
1050 - , id, NULL
1051 - , "remoting"
1052 - , "netframework.clrremoting_remote_calls"
1053 - , "Remote Procedure Calls (RPC) invoked"
1054 - , "calls/s"
1055 - , PLUGIN_WINDOWS_NAME
1056 - , "PerflibNetFramework"
1057 - , PRIO_NETFRAMEWORK_CLR_REMOTING_REMOTE_CALLS
1058 - , update_every
1059 - , RRDSET_TYPE_LINE
1060 - );
1061 -
1062 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_remote_calls_total", windows_shared_buffer);
1063 - p->rd_clrremoting_remote_calls = rrddim_add(p->st_clrremoting_remote_calls,
1064 - id,
1065 - "contexts",
1066 - 1,
1067 - 1,
1068 - RRD_ALGORITHM_INCREMENTAL);
1069 -
1070 - rrdlabels_add(p->st_clrremoting_remote_calls->rrdlabels,
1071 - "process",
1072 - windows_shared_buffer,
1073 - RRDLABEL_SRC_AUTO);
1050 + p->st_clrremoting_remote_calls = rrdset_create_localhost(
1051 + "netframework",
1052 + id,
1053 + NULL,
1054 + "remoting",
1055 + "netframework.clrremoting_remote_calls",
1056 + "Remote Procedure Calls (RPC) invoked",
1057 + "calls/s",
1058 + PLUGIN_WINDOWS_NAME,
1059 + "PerflibNetFramework",
1060 + PRIO_NETFRAMEWORK_CLR_REMOTING_REMOTE_CALLS,
1061 + update_every,
1062 + RRDSET_TYPE_LINE);
1063 +
1064 + snprintfz(
1065 + id, RRD_ID_LENGTH_MAX, "netframework_%s_clrremoting_remote_calls_total", windows_shared_buffer);
1066 + p->rd_clrremoting_remote_calls =
1067 + rrddim_add(p->st_clrremoting_remote_calls, id, "contexts", 1, 1, RRD_ALGORITHM_INCREMENTAL);
1068 +
1069 + rrdlabels_add(
1070 + p->st_clrremoting_remote_calls->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1071 }
1072
1076 - rrddim_set_by_pointer(p->st_clrremoting_remote_calls,
1077 - p->rd_clrremoting_remote_calls,
1078 - (collected_number)p->NETFrameworkCLRRemotingContexts.current.Data);
1073 + rrddim_set_by_pointer(
1074 + p->st_clrremoting_remote_calls,
1075 + p->rd_clrremoting_remote_calls,
1076 + (collected_number)p->NETFrameworkCLRRemotingContexts.current.Data);
1077 rrdset_done(p->st_clrremoting_remote_calls);
1078 }
1079 }
1080 }
1081
1084 -static void netdata_framework_clr_security(PERF_DATA_BLOCK *pDataBlock,
1085 - PERF_OBJECT_TYPE *pObjectType,
1086 - int update_every)
1082 +static void netdata_framework_clr_security(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1083 {
1084 char id[RRD_ID_LENGTH_MAX + 1];
1085 PERF_INSTANCE_DEFINITION *pi = NULL;
@@ -1104,36 +1100,33 @@ static void netdata_framework_clr_security(PERF_DATA_BLOCK *pDataBlock,
1100 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityLinkTimeChecks)) {
1101 if (!p->st_clrsecurity_link_time_checks) {
1102 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrsecurity_link_time_checks", windows_shared_buffer);
1107 - p->st_clrsecurity_link_time_checks = rrdset_create_localhost("netframework"
1108 - , id, NULL
1109 - , "security"
1110 - , "netframework.clrsecurity_link_time_checks"
1111 - , "Link-time code access security checks"
1112 - , "checks/s"
1113 - , PLUGIN_WINDOWS_NAME
1114 - , "PerflibNetFramework"
1115 - , PRIO_NETFRAMEWORK_CLR_SECURITY_LINK_TIME_CHECKS
1116 - , update_every
1117 - , RRDSET_TYPE_LINE
1118 - );
1119 -
1120 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_link_time_checks_total", windows_shared_buffer);
1121 - p->rd_clrsecurity_link_time_checks = rrddim_add(p->st_clrsecurity_link_time_checks,
1122 - id,
1123 - "linktime",
1124 - 1,
1125 - 1,
1126 - RRD_ALGORITHM_INCREMENTAL);
1127 -
1128 - rrdlabels_add(p->st_clrsecurity_link_time_checks->rrdlabels,
1129 - "process",
1130 - windows_shared_buffer,
1131 - RRDLABEL_SRC_AUTO);
1103 + p->st_clrsecurity_link_time_checks = rrdset_create_localhost(
1104 + "netframework",
1105 + id,
1106 + NULL,
1107 + "security",
1108 + "netframework.clrsecurity_link_time_checks",
1109 + "Link-time code access security checks",
1110 + "checks/s",
1111 + PLUGIN_WINDOWS_NAME,
1112 + "PerflibNetFramework",
1113 + PRIO_NETFRAMEWORK_CLR_SECURITY_LINK_TIME_CHECKS,
1114 + update_every,
1115 + RRDSET_TYPE_LINE);
1116 +
1117 + snprintfz(
1118 + id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_link_time_checks_total", windows_shared_buffer);
1119 + p->rd_clrsecurity_link_time_checks =
1120 + rrddim_add(p->st_clrsecurity_link_time_checks, id, "linktime", 1, 1, RRD_ALGORITHM_INCREMENTAL);
1121 +
1122 + rrdlabels_add(
1123 + p->st_clrsecurity_link_time_checks->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1124 }
1125
1134 - rrddim_set_by_pointer(p->st_clrsecurity_link_time_checks,
1135 - p->rd_clrsecurity_link_time_checks,
1136 - (collected_number)p->NETFrameworkCLRSecurityLinkTimeChecks.current.Data);
1126 + rrddim_set_by_pointer(
1127 + p->st_clrsecurity_link_time_checks,
1128 + p->rd_clrsecurity_link_time_checks,
1129 + (collected_number)p->NETFrameworkCLRSecurityLinkTimeChecks.current.Data);
1130 rrdset_done(p->st_clrsecurity_link_time_checks);
1131 }
1132
@@ -1141,119 +1134,108 @@ static void netdata_framework_clr_security(PERF_DATA_BLOCK *pDataBlock,
1134 perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityFrequency_PerfTime)) {
1135 if (!p->st_clrsecurity_link_time_checks) {
1136 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrsecurity_checks_time", windows_shared_buffer);
1144 - p->st_clrsecurity_link_time_checks = rrdset_create_localhost("netframework"
1145 - , id, NULL
1146 - , "security"
1147 - , "netframework.clrsecurity_checks_time"
1148 - , "Time spent performing runtime code access security checks."
1149 - , "percentage"
1150 - , PLUGIN_WINDOWS_NAME
1151 - , "PerflibNetFramework"
1152 - , PRIO_NETFRAMEWORK_CLR_SECURITY_RT_CHECKS_TIME
1153 - , update_every
1154 - , RRDSET_TYPE_LINE
1155 - );
1156 -
1157 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_checks_time_percent", windows_shared_buffer);
1158 - p->rd_clrsecurity_link_time_checks = rrddim_add(p->st_clrsecurity_link_time_checks,
1159 - id,
1160 - "time",
1161 - 1,
1162 - 100,
1163 - RRD_ALGORITHM_ABSOLUTE);
1164 -
1165 - rrdlabels_add(p->st_clrsecurity_link_time_checks->rrdlabels,
1166 - "process",
1167 - windows_shared_buffer,
1168 - RRDLABEL_SRC_AUTO);
1137 + p->st_clrsecurity_link_time_checks = rrdset_create_localhost(
1138 + "netframework",
1139 + id,
1140 + NULL,
1141 + "security",
1142 + "netframework.clrsecurity_checks_time",
1143 + "Time spent performing runtime code access security checks.",
1144 + "percentage",
1145 + PLUGIN_WINDOWS_NAME,
1146 + "PerflibNetFramework",
1147 + PRIO_NETFRAMEWORK_CLR_SECURITY_RT_CHECKS_TIME,
1148 + update_every,
1149 + RRDSET_TYPE_LINE);
1150 +
1151 + snprintfz(
1152 + id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_checks_time_percent", windows_shared_buffer);
1153 + p->rd_clrsecurity_link_time_checks =
1154 + rrddim_add(p->st_clrsecurity_link_time_checks, id, "time", 1, 100, RRD_ALGORITHM_ABSOLUTE);
1155 +
1156 + rrdlabels_add(
1157 + p->st_clrsecurity_link_time_checks->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1158 }
1159
1160 NETDATA_DOUBLE value = (NETDATA_DOUBLE)p->NETFrameworkCLRSecurityPercentTimeinRTChecks.current.Data;
1161 value /= (NETDATA_DOUBLE)p->NETFrameworkCLRSecurityFrequency_PerfTime.current.Data;
1162
1174 - rrddim_set_by_pointer(p->st_clrsecurity_link_time_checks,
1175 - p->rd_clrsecurity_link_time_checks,
1176 - (collected_number)(value * 100.0));
1163 + rrddim_set_by_pointer(
1164 + p->st_clrsecurity_link_time_checks,
1165 + p->rd_clrsecurity_link_time_checks,
1166 + (collected_number)(value * 100.0));
1167 rrdset_done(p->st_clrsecurity_link_time_checks);
1168 }
1169
1170 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityStackWalkDepth)) {
1171 if (!p->st_clrsecurity_stack_walk_depth) {
1172 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrsecurity_stack_walk_depth", windows_shared_buffer);
1183 - p->st_clrsecurity_stack_walk_depth = rrdset_create_localhost("netframework"
1184 - , id, NULL
1185 - , "security"
1186 - , "netframework.clrsecurity_stack_walk_depth"
1187 - , "Depth of the stack"
1188 - , "depth"
1189 - , PLUGIN_WINDOWS_NAME
1190 - , "PerflibNetFramework"
1191 - , PRIO_NETFRAMEWORK_CLR_SECURITY_STACK_WALK_DEPTH
1192 - , update_every
1193 - , RRDSET_TYPE_LINE
1194 - );
1173 + p->st_clrsecurity_stack_walk_depth = rrdset_create_localhost(
1174 + "netframework",
1175 + id,
1176 + NULL,
1177 + "security",
1178 + "netframework.clrsecurity_stack_walk_depth",
1179 + "Depth of the stack",
1180 + "depth",
1181 + PLUGIN_WINDOWS_NAME,
1182 + "PerflibNetFramework",
1183 + PRIO_NETFRAMEWORK_CLR_SECURITY_STACK_WALK_DEPTH,
1184 + update_every,
1185 + RRDSET_TYPE_LINE);
1186
1187 snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_stack_walk_depth", windows_shared_buffer);
1197 - p->rd_clrsecurity_stack_walk_depth = rrddim_add(p->st_clrsecurity_stack_walk_depth,
1198 - id,
1199 - "stack",
1200 - 1,
1201 - 1,
1202 - RRD_ALGORITHM_ABSOLUTE);
1203 -
1204 - rrdlabels_add(p->st_clrsecurity_stack_walk_depth->rrdlabels,
1205 - "process",
1206 - windows_shared_buffer,
1207 - RRDLABEL_SRC_AUTO);
1188 + p->rd_clrsecurity_stack_walk_depth =
1189 + rrddim_add(p->st_clrsecurity_stack_walk_depth, id, "stack", 1, 1, RRD_ALGORITHM_ABSOLUTE);
1190 +
1191 + rrdlabels_add(
1192 + p->st_clrsecurity_stack_walk_depth->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1193 }
1194
1210 - rrddim_set_by_pointer(p->st_clrsecurity_stack_walk_depth,
1211 - p->rd_clrsecurity_stack_walk_depth,
1212 - (collected_number)p->NETFrameworkCLRSecurityStackWalkDepth.current.Data);
1195 + rrddim_set_by_pointer(
1196 + p->st_clrsecurity_stack_walk_depth,
1197 + p->rd_clrsecurity_stack_walk_depth,
1198 + (collected_number)p->NETFrameworkCLRSecurityStackWalkDepth.current.Data);
1199 rrdset_done(p->st_clrsecurity_stack_walk_depth);
1200 }
1201
1202 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityRunTimeChecks)) {
1203 if (!p->st_clrsecurity_stack_walk_depth) {
1204 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrsecurity_runtime_checks", windows_shared_buffer);
1219 - p->st_clrsecurity_stack_walk_depth = rrdset_create_localhost("netframework"
1220 - , id, NULL
1221 - , "security"
1222 - , "netframework.clrsecurity_runtime_checks"
1223 - , "Runtime code access security checks performed"
1224 - , "checks/s"
1225 - , PLUGIN_WINDOWS_NAME
1226 - , "PerflibNetFramework"
1227 - , PRIO_NETFRAMEWORK_CLR_SECURITY_RUNTIME_CHECKS
1228 - , update_every
1229 - , RRDSET_TYPE_LINE
1230 - );
1231 -
1232 - snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_runtime_checks_total", windows_shared_buffer);
1233 - p->rd_clrsecurity_stack_walk_depth = rrddim_add(p->st_clrsecurity_stack_walk_depth,
1234 - id,
1235 - "runtime",
1236 - 1,
1237 - 1,
1238 - RRD_ALGORITHM_INCREMENTAL);
1239 -
1240 - rrdlabels_add(p->st_clrsecurity_stack_walk_depth->rrdlabels,
1241 - "process",
1242 - windows_shared_buffer,
1243 - RRDLABEL_SRC_AUTO);
1205 + p->st_clrsecurity_stack_walk_depth = rrdset_create_localhost(
1206 + "netframework",
1207 + id,
1208 + NULL,
1209 + "security",
1210 + "netframework.clrsecurity_runtime_checks",
1211 + "Runtime code access security checks performed",
1212 + "checks/s",
1213 + PLUGIN_WINDOWS_NAME,
1214 + "PerflibNetFramework",
1215 + PRIO_NETFRAMEWORK_CLR_SECURITY_RUNTIME_CHECKS,
1216 + update_every,
1217 + RRDSET_TYPE_LINE);
1218 +
1219 + snprintfz(
1220 + id, RRD_ID_LENGTH_MAX, "netframework_%s_clrsecurity_runtime_checks_total", windows_shared_buffer);
1221 + p->rd_clrsecurity_stack_walk_depth =
1222 + rrddim_add(p->st_clrsecurity_stack_walk_depth, id, "runtime", 1, 1, RRD_ALGORITHM_INCREMENTAL);
1223 +
1224 + rrdlabels_add(
1225 + p->st_clrsecurity_stack_walk_depth->rrdlabels, "process", windows_shared_buffer, RRDLABEL_SRC_AUTO);
1226 }
1227
1246 - rrddim_set_by_pointer(p->st_clrsecurity_stack_walk_depth,
1247 - p->rd_clrsecurity_stack_walk_depth,
1248 - (collected_number)p->NETFrameworkCLRSecurityRunTimeChecks.current.Data);
1228 + rrddim_set_by_pointer(
1229 + p->st_clrsecurity_stack_walk_depth,
1230 + p->rd_clrsecurity_stack_walk_depth,
1231 + (collected_number)p->NETFrameworkCLRSecurityRunTimeChecks.current.Data);
1232 rrdset_done(p->st_clrsecurity_stack_walk_depth);
1233 }
1234 }
1235 }
1236
1254 -static void netdata_framework_clr_locks_and_threads(PERF_DATA_BLOCK *pDataBlock,
1255 - PERF_OBJECT_TYPE *pObjectType,
1256 - int update_every)
1237 +static void
1238 +netdata_framework_clr_locks_and_threads(PERF_DATA_BLOCK *pDataBlock, PERF_OBJECT_TYPE *pObjectType, int update_every)
1239 {
1240 char id[RRD_ID_LENGTH_MAX + 1];
1241 PERF_INSTANCE_DEFINITION *pi = NULL;
@@ -1352,118 +1334,119 @@ static void netdata_framework_clr_locks_and_threads(PERF_DATA_BLOCK *pDataBlock,
1334
1335 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsCurrentPhysicalThreads)) {
1336 if (!p->st_clrlocksandthreads_current_physical_threads) {
1355 - snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrlocksandthreads_current_physical_threads", windows_shared_buffer);
1356 - p->st_clrlocksandthreads_current_physical_threads = rrdset_create_localhost("netframework",
1357 - id,
1358 - NULL,
1359 - "locks threads",
1360 - "netframework.clrlocksandthreads_current_physical_threads",
1361 - "Physical threads",
1362 - "threads",
1363 - PLUGIN_WINDOWS_NAME,
1364 - "PerflibNetFramework",
1365 - PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_CURRENT_PHYSICAL_THREADS,
1366 - update_every,
1367 - RRDSET_TYPE_LINE);
1368 -
1369 - snprintfz(id,
1370 - RRD_ID_LENGTH_MAX,
1371 - "netframework_%s_clrlocksandthreads_physical_threads_current",
1372 - windows_shared_buffer);
1373 - p->rd_locksandthreads_current_physical_threads = rrddim_add(p->st_clrlocksandthreads_current_physical_threads,
1374 - id,
1375 - "physical",
1376 - 1,
1377 - 1,
1378 - RRD_ALGORITHM_ABSOLUTE);
1379 -
1380 - rrdlabels_add(p->st_clrlocksandthreads_current_physical_threads->rrdlabels,
1381 - "process",
1382 - windows_shared_buffer,
1383 - RRDLABEL_SRC_AUTO);
1337 + snprintfz(
1338 + id, RRD_ID_LENGTH_MAX, "%s_clrlocksandthreads_current_physical_threads", windows_shared_buffer);
1339 + p->st_clrlocksandthreads_current_physical_threads = rrdset_create_localhost(
1340 + "netframework",
1341 + id,
1342 + NULL,
1343 + "locks threads",
1344 + "netframework.clrlocksandthreads_current_physical_threads",
1345 + "Physical threads",
1346 + "threads",
1347 + PLUGIN_WINDOWS_NAME,
1348 + "PerflibNetFramework",
1349 + PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_CURRENT_PHYSICAL_THREADS,
1350 + update_every,
1351 + RRDSET_TYPE_LINE);
1352 +
1353 + snprintfz(
1354 + id,
1355 + RRD_ID_LENGTH_MAX,
1356 + "netframework_%s_clrlocksandthreads_physical_threads_current",
1357 + windows_shared_buffer);
1358 + p->rd_locksandthreads_current_physical_threads = rrddim_add(
1359 + p->st_clrlocksandthreads_current_physical_threads, id, "physical", 1, 1, RRD_ALGORITHM_ABSOLUTE);
1360 +
1361 + rrdlabels_add(
1362 + p->st_clrlocksandthreads_current_physical_threads->rrdlabels,
1363 + "process",
1364 + windows_shared_buffer,
1365 + RRDLABEL_SRC_AUTO);
1366 }
1367
1386 - rrddim_set_by_pointer(p->st_clrlocksandthreads_current_physical_threads,
1387 - p->rd_locksandthreads_current_physical_threads,
1388 - (collected_number)p->NETFrameworkCLRLocksAndThreadsCurrentPhysicalThreads.current.Data);
1368 + rrddim_set_by_pointer(
1369 + p->st_clrlocksandthreads_current_physical_threads,
1370 + p->rd_locksandthreads_current_physical_threads,
1371 + (collected_number)p->NETFrameworkCLRLocksAndThreadsCurrentPhysicalThreads.current.Data);
1372 rrdset_done(p->st_clrlocksandthreads_current_physical_threads);
1373 }
1374
1375 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsRecognizedThreads)) {
1376 if (!p->st_clrlocksandthreads_recognized_threads) {
1377 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrlocksandthreads_recognized_threads", windows_shared_buffer);
1395 - p->st_clrlocksandthreads_recognized_threads = rrdset_create_localhost("netframework",
1396 - id,
1397 - NULL,
1398 - "locks threads",
1399 - "netframework.clrlocksandthreads_recognized_threads",
1400 - "Threads recognized by the runtime",
1401 - "threads/s",
1402 - PLUGIN_WINDOWS_NAME,
1403 - "PerflibNetFramework",
1404 - PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_RECOGNIZED_THREADS,
1405 - update_every,
1406 - RRDSET_TYPE_LINE);
1407 -
1408 - snprintfz(id,
1409 - RRD_ID_LENGTH_MAX,
1410 - "netframework_%s_clrlocksandthreads_recognized_threads_total",
1411 - windows_shared_buffer);
1412 - p->rd_locksandthreads_recognized_threads = rrddim_add(p->st_clrlocksandthreads_recognized_threads,
1413 - id,
1414 - "threads",
1415 - 1,
1416 - 1,
1417 - RRD_ALGORITHM_ABSOLUTE);
1418 -
1419 - rrdlabels_add(p->st_clrlocksandthreads_recognized_threads->rrdlabels,
1420 - "process",
1421 - windows_shared_buffer,
1422 - RRDLABEL_SRC_AUTO);
1378 + p->st_clrlocksandthreads_recognized_threads = rrdset_create_localhost(
1379 + "netframework",
1380 + id,
1381 + NULL,
1382 + "locks threads",
1383 + "netframework.clrlocksandthreads_recognized_threads",
1384 + "Threads recognized by the runtime",
1385 + "threads/s",
1386 + PLUGIN_WINDOWS_NAME,
1387 + "PerflibNetFramework",
1388 + PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_RECOGNIZED_THREADS,
1389 + update_every,
1390 + RRDSET_TYPE_LINE);
1391 +
1392 + snprintfz(
1393 + id,
1394 + RRD_ID_LENGTH_MAX,
1395 + "netframework_%s_clrlocksandthreads_recognized_threads_total",
1396 + windows_shared_buffer);
1397 + p->rd_locksandthreads_recognized_threads = rrddim_add(
1398 + p->st_clrlocksandthreads_recognized_threads, id, "threads", 1, 1, RRD_ALGORITHM_ABSOLUTE);
1399 +
1400 + rrdlabels_add(
1401 + p->st_clrlocksandthreads_recognized_threads->rrdlabels,
1402 + "process",
1403 + windows_shared_buffer,
1404 + RRDLABEL_SRC_AUTO);
1405 }
1406
1425 - rrddim_set_by_pointer(p->st_clrlocksandthreads_recognized_threads,
1426 - p->rd_locksandthreads_recognized_threads,
1427 - (collected_number)p->NETFrameworkCLRLocksAndThreadsRecognizedThreads.current.Data);
1407 + rrddim_set_by_pointer(
1408 + p->st_clrlocksandthreads_recognized_threads,
1409 + p->rd_locksandthreads_recognized_threads,
1410 + (collected_number)p->NETFrameworkCLRLocksAndThreadsRecognizedThreads.current.Data);
1411 rrdset_done(p->st_clrlocksandthreads_recognized_threads);
1412 }
1413
1414 if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsContentions)) {
1415 if (!p->st_clrlocksandthreads_contentions) {
1416 snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrlocksandthreads_contentions", windows_shared_buffer);
1434 - p->st_clrlocksandthreads_contentions = rrdset_create_localhost("netframework",
1435 - id,
1436 - NULL,
1437 - "locks threads",
1438 - "netframework.clrlocksandthreads_contentions",
1439 - "Fails to acquire a managed lock",
1440 - "contentions/s",
1441 - PLUGIN_WINDOWS_NAME,
1442 - "PerflibNetFramework",
1443 - PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_CONTENTIONS,
1444 - update_every,
1445 - RRDSET_TYPE_LINE);
1446 -
1447 - snprintfz(id,
1448 - RRD_ID_LENGTH_MAX,
1449 - "netframework_%s_clrlocksandthreads_contentions_total",
1450 - windows_shared_buffer);
1451 - p->rd_locksandthreads_contentions = rrddim_add(p->st_clrlocksandthreads_contentions,
1452 - id,
1453 - "contentions",
1454 - 1,
1455 - 1,
1456 - RRD_ALGORITHM_INCREMENTAL);
1457 -
1458 - rrdlabels_add(p->st_clrlocksandthreads_contentions->rrdlabels,
1459 - "process",
1460 - windows_shared_buffer,
1461 - RRDLABEL_SRC_AUTO);
1417 + p->st_clrlocksandthreads_contentions = rrdset_create_localhost(
1418 + "netframework",
1419 + id,
1420 + NULL,
1421 + "locks threads",
1422 + "netframework.clrlocksandthreads_contentions",
1423 + "Fails to acquire a managed lock",
1424 + "contentions/s",
1425 + PLUGIN_WINDOWS_NAME,
1426 + "PerflibNetFramework",
1427 + PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_CONTENTIONS,
1428 + update_every,
1429 + RRDSET_TYPE_LINE);
1430 +
1431 + snprintfz(
1432 + id,
1433 + RRD_ID_LENGTH_MAX,
1434 + "netframework_%s_clrlocksandthreads_contentions_total",
1435 + windows_shared_buffer);
1436 + p->rd_locksandthreads_contentions = rrddim_add(
1437 + p->st_clrlocksandthreads_contentions, id, "contentions", 1, 1, RRD_ALGORITHM_INCREMENTAL);
1438 +
1439 + rrdlabels_add(
1440 + p->st_clrlocksandthreads_contentions->rrdlabels,
1441 + "process",
1442 + windows_shared_buffer,
1443 + RRDLABEL_SRC_AUTO);
1444 }
1445
1464 - rrddim_set_by_pointer(p->st_clrlocksandthreads_contentions,
1465 - p->rd_locksandthreads_contentions,
1466 - (collected_number)p->NETFrameworkCLRLocksAndThreadsContentions.current.Data);
1446 + rrddim_set_by_pointer(
1447 + p->st_clrlocksandthreads_contentions,
1448 + p->rd_locksandthreads_contentions,
1449 + (collected_number)p->NETFrameworkCLRLocksAndThreadsContentions.current.Data);
1450 rrdset_done(p->st_clrlocksandthreads_contentions);
1451 }
1452 }
@@ -1473,17 +1456,18 @@ struct netdata_netframework_objects {
1456 char *object;
1457 void (*fnct)(PERF_DATA_BLOCK *, PERF_OBJECT_TYPE *, int);
1458 } netframewrk_obj[NETDATA_NETFRAMEWORK_END] = {
1476 - {.fnct = netdata_framework_clr_exceptions, .object = ".NET CLR Exceptions" },
1477 - {.fnct = netdata_framework_clr_interop, .object = ".NET CLR Interop" },
1478 - {.fnct = netdata_framework_clr_jit, .object = ".NET CLR Jit" },
1479 - {.fnct = netdata_framework_clr_loading, .object = ".NET CLR Loading" },
1480 - {.fnct = netdata_framework_clr_remoting, .object = ".NET CLR Remoting" },
1481 - {.fnct = netdata_framework_clr_security, .object = ".NET CLR Security" },
1482 - {.fnct = netdata_framework_clr_locks_and_threads, .object = ".NET CLR LocksAndThreads" }
1459 + {.fnct = netdata_framework_clr_exceptions, .object = ".NET CLR Exceptions"},
1460 + {.fnct = netdata_framework_clr_interop, .object = ".NET CLR Interop"},
1461 + {.fnct = netdata_framework_clr_jit, .object = ".NET CLR Jit"},
1462 + {.fnct = netdata_framework_clr_loading, .object = ".NET CLR Loading"},
1463 + {.fnct = netdata_framework_clr_remoting, .object = ".NET CLR Remoting"},
1464 + {.fnct = netdata_framework_clr_security, .object = ".NET CLR Security"},
1465 + {.fnct = netdata_framework_clr_locks_and_threads, .object = ".NET CLR LocksAndThreads"}
1466
1467 };
1468
1486 -int do_PerflibNetFramework(int update_every, usec_t dt __maybe_unused) {
1469 +int do_PerflibNetFramework(int update_every, usec_t dt __maybe_unused)
1470 +{
1471 static bool initialized = false;
1472
1473 if (unlikely(!initialized)) {