@cryptotaxi247 / netdata-1 / commits / 9c00739ff

NetFramework (Part I) (#18762)

thiagoftsm committed Oct 14, 2024 at 12:11 UTC 9c00739ffa2bc9de65b0a35f7f0793df8522a2d4
4 files changed +916 -13
CMakeLists.txt
+1
@@ -1461,6 +1461,7 @@ set(WINDOWS_PLUGIN_FILES
1461 src/collectors/windows.plugin/perflib-thermalzone.c
1462 src/collectors/windows.plugin/perflib-objects.c
1463 src/collectors/windows.plugin/perflib-network.c
1464 + src/collectors/windows.plugin/perflib-netframework.c
1465 src/collectors/windows.plugin/perflib-memory.c
1466 src/collectors/windows.plugin/perflib-processes.c
1467 src/collectors/windows.plugin/perflib-web-service.c
src/collectors/windows.plugin/perflib-netframework.c new
+878
@@ -0,0 +1,878 @@
1 +// SPDX-License-Identifier: GPL-3.0-or-later
2 +
3 +#include "windows_plugin.h"
4 +#include "windows-internals.h"
5 +
6 +enum netdata_netframework_metrics {
7 + NETDATA_NETFRAMEWORK_EXCEPTIONS,
8 + NETDATA_NETFRAMEWORK_INTEROP,
9 + NETDATA_NETFRAMEWORK_JIT,
10 + NETDATA_NETFRAMEWORK_LOADING,
11 +
12 + NETDATA_NETFRAMEWORK_END
13 +};
14 +
15 +struct net_framework_instances {
16 + RRDSET *st_clrexception_thrown;
17 + RRDDIM *rd_clrexception_thrown;
18 +
19 + RRDSET *st_clrexception_filters;
20 + RRDDIM *rd_clrexception_filters;
21 +
22 + RRDSET *st_clrexception_finallys;
23 + RRDDIM *rd_clrexception_finallys;
24 +
25 + RRDSET *st_clrexception_total_catch_depth;
26 + RRDDIM *rd_clrexception_total_catch_depth;
27 +
28 + RRDSET *st_clrinterop_com_callable_wrappers;
29 + RRDDIM *rd_clrinterop_com_callable_wrappers;
30 +
31 + RRDSET *st_clrinterop_marshalling;
32 + RRDDIM *rd_clrinterop_marshalling;
33 +
34 + RRDSET *st_clrinterop_interop_stubs_created;
35 + RRDDIM *rd_clrinterop_interop_stubs_created;
36 +
37 + RRDSET *st_clrjit_methods;
38 + RRDDIM *rd_clrjit_methods;
39 +
40 + RRDSET *st_clrjit_time;
41 + RRDDIM *rd_clrjit_time;
42 +
43 + RRDSET *st_clrjit_standard_failures;
44 + RRDDIM *rd_clrjit_standard_failures;
45 +
46 + RRDSET *st_clrjit_il_bytes;
47 + RRDDIM *rd_clrjit_il_bytes;
48 +
49 + RRDSET *st_clrloading_heap_size;
50 + RRDDIM *rd_clrloading_heap_size;
51 +
52 + RRDSET *st_clrloading_app_domains_loaded;
53 + RRDDIM *rd_clrloading_app_domains_loaded;
54 +
55 + RRDSET *st_clrloading_app_domains_unloaded;
56 + RRDDIM *rd_clrloading_app_domains_unloaded;
57 +
58 + RRDSET *st_clrloading_assemblies_loaded;
59 + RRDDIM *rd_clrloading_assemblies_loaded;
60 +
61 + RRDSET *st_clrloading_classes_loaded;
62 + RRDDIM *rd_clrloading_classes_loaded;
63 +
64 + RRDSET *st_clrloading_class_load_failure;
65 + RRDDIM *rd_clrloading_class_load_failure;
66 +
67 + COUNTER_DATA NETFrameworkCLRExceptionThrown;
68 + COUNTER_DATA NETFrameworkCLRExceptionFilters;
69 + COUNTER_DATA NETFrameworkCLRExceptionFinallys;
70 + COUNTER_DATA NETFrameworkCLRExceptionTotalCatchDepth;
71 +
72 + COUNTER_DATA NETFrameworkCLRInteropCOMCallableWrappers;
73 + COUNTER_DATA NETFrameworkCLRInteropMarshalling;
74 + COUNTER_DATA NETFrameworkCLRInteropStubsCreated;
75 +
76 + COUNTER_DATA NETFrameworkCLRJITMethods;
77 + COUNTER_DATA NETFrameworkCLRJITPercentTime;
78 + COUNTER_DATA NETFrameworkCLRJITFrequencyTime;
79 + COUNTER_DATA NETFrameworkCLRJITStandardFailures;
80 + COUNTER_DATA NETFrameworkCLRJITIlBytes;
81 +
82 + COUNTER_DATA NETFrameworkCLRLoadingHeapSize;
83 + COUNTER_DATA NETFrameworkCLRLoadingAppDomainsLoaded;
84 + COUNTER_DATA NETFrameworkCLRLoadingAppDomainsUnloaded;
85 + COUNTER_DATA NETFrameworkCLRLoadingAssembliesLoaded;
86 + COUNTER_DATA NETFrameworkCLRLoadingClassesLoaded;
87 + COUNTER_DATA NETFrameworkCLRLoadingClassLoadFailure;
88 +};
89 +
90 +static inline void initialize_net_framework_processes_keys(struct net_framework_instances *p) {
91 + p->NETFrameworkCLRExceptionFilters.key = "# of Filters / sec";
92 + p->NETFrameworkCLRExceptionFinallys.key = "# of Finallys / sec";
93 + p->NETFrameworkCLRExceptionThrown.key = "# of Exceps Thrown / sec";
94 + p->NETFrameworkCLRExceptionTotalCatchDepth.key = "Throw To Catch Depth / sec";
95 +
96 + p->NETFrameworkCLRInteropCOMCallableWrappers.key = "# of CCWs";
97 + p->NETFrameworkCLRInteropMarshalling.key = "# of Stubs";
98 + p->NETFrameworkCLRInteropStubsCreated.key = "# of marshalling";
99 +
100 + p->NETFrameworkCLRJITMethods.key = "# of Methods Jitted";
101 + p->NETFrameworkCLRJITPercentTime.key = "% Time in Jit";
102 + p->NETFrameworkCLRJITFrequencyTime.key = "IL Bytes Jitted / sec";
103 + p->NETFrameworkCLRJITStandardFailures.key = "Standard Jit Failures";
104 + p->NETFrameworkCLRJITIlBytes.key = "# of IL Bytes Jitted";
105 +
106 + p->NETFrameworkCLRLoadingHeapSize.key = "Bytes in Loader Heap";
107 + p->NETFrameworkCLRLoadingAppDomainsLoaded.key = "Rate of appdomains";
108 + p->NETFrameworkCLRLoadingAppDomainsUnloaded.key = "Total appdomains unloaded";
109 + p->NETFrameworkCLRLoadingAssembliesLoaded.key = "Total Assemblies";
110 + p->NETFrameworkCLRLoadingClassesLoaded.key = "Total Classes Loaded";
111 + p->NETFrameworkCLRLoadingClassLoadFailure.key = "Total # of Load Failures";
112 +}
113 +
114 +void dict_net_framework_processes_insert_cb(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused) {
115 + struct net_framework_instances *p = value;
116 + initialize_net_framework_processes_keys(p);
117 +}
118 +
119 +static DICTIONARY *processes = NULL;
120 +
121 +static void initialize(void) {
122 + processes = dictionary_create_advanced(DICT_OPTION_DONT_OVERWRITE_VALUE |
123 + DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct net_framework_instances));
124 +
125 + dictionary_register_insert_callback(processes, dict_net_framework_processes_insert_cb, NULL);
126 +}
127 +
128 +static void netdata_framework_clr_exceptions(PERF_DATA_BLOCK *pDataBlock,
129 + PERF_OBJECT_TYPE *pObjectType,
130 + int update_every)
131 +{
132 + PERF_INSTANCE_DEFINITION *pi = NULL;
133 + char id[RRD_ID_LENGTH_MAX + 1];
134 + for(LONG i = 0; i < pObjectType->NumInstances ; i++) {
135 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
136 + if (!pi)
137 + break;
138 +
139 + if(!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))
140 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
141 +
142 + if(strcasecmp(windows_shared_buffer, "_Global_") == 0)
143 + continue;
144 +
145 + netdata_fix_chart_name(windows_shared_buffer);
146 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));
147 +
148 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRExceptionThrown)) {
149 + if (!p->st_clrexception_thrown) {
150 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrexception_thrown", windows_shared_buffer);
151 + p->st_clrexception_thrown = rrdset_create_localhost("netframework"
152 + , id, NULL
153 + , "exceptions"
154 + , "netframework.clrexception_thrown"
155 + , "Thrown exceptions"
156 + , "exceptions/s"
157 + , PLUGIN_WINDOWS_NAME
158 + , "PerflibNetFramework"
159 + , PRIO_NETFRAMEWORK_CLR_EXCEPTION_THROWN
160 + , update_every
161 + , RRDSET_TYPE_LINE
162 + );
163 +
164 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrexception_thrown_total", windows_shared_buffer);
165 + p->rd_clrexception_thrown = rrddim_add(p->st_clrexception_thrown,
166 + id,
167 + "exceptions",
168 + 1,
169 + 1,
170 + RRD_ALGORITHM_INCREMENTAL);
171 +
172 + rrdlabels_add(p->st_clrexception_thrown->rrdlabels,
173 + "process",
174 + windows_shared_buffer,
175 + RRDLABEL_SRC_AUTO);
176 + }
177 +
178 + rrddim_set_by_pointer(p->st_clrexception_thrown,
179 + p->rd_clrexception_thrown,
180 + (collected_number)p->NETFrameworkCLRExceptionThrown.current.Data);
181 + rrdset_done(p->st_clrexception_thrown);
182 + }
183 +
184 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRExceptionFilters)) {
185 + if (!p->st_clrexception_filters) {
186 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrexception_filters", windows_shared_buffer);
187 + p->st_clrexception_filters = rrdset_create_localhost("netframework"
188 + , id, NULL
189 + , "exceptions"
190 + , "netframework.clrexception_filters"
191 + , "Thrown exceptions filters"
192 + , "filters/s"
193 + , PLUGIN_WINDOWS_NAME
194 + , "PerflibNetFramework"
195 + , PRIO_NETFRAMEWORK_CLR_EXCEPTION_FILTERS
196 + , update_every
197 + , RRDSET_TYPE_LINE
198 + );
199 +
200 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrexception_filters_total", windows_shared_buffer);
201 + p->rd_clrexception_filters = rrddim_add(p->st_clrexception_filters,
202 + id,
203 + "filters",
204 + 1,
205 + 1,
206 + RRD_ALGORITHM_INCREMENTAL);
207 +
208 + rrdlabels_add(p->st_clrexception_filters->rrdlabels,
209 + "process",
210 + windows_shared_buffer,
211 + RRDLABEL_SRC_AUTO);
212 + }
213 +
214 + rrddim_set_by_pointer(p->st_clrexception_filters,
215 + p->rd_clrexception_filters,
216 + (collected_number)p->NETFrameworkCLRExceptionFilters.current.Data);
217 + rrdset_done(p->st_clrexception_filters);
218 + }
219 +
220 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRExceptionFinallys)) {
221 + if (!p->st_clrexception_finallys) {
222 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrexception_finallys", windows_shared_buffer);
223 + p->st_clrexception_finallys = rrdset_create_localhost("netframework"
224 + , id, NULL
225 + , "exceptions"
226 + , "netframework.clrexception_finallys"
227 + , "Executed finally blocks"
228 + , "finallys/s"
229 + , PLUGIN_WINDOWS_NAME
230 + , "PerflibNetFramework"
231 + , PRIO_NETFRAMEWORK_CLR_EXCEPTION_FINALLYS
232 + , update_every
233 + , RRDSET_TYPE_LINE
234 + );
235 +
236 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrexception_finallys_total", windows_shared_buffer);
237 + p->rd_clrexception_finallys = rrddim_add(p->st_clrexception_finallys,
238 + id,
239 + "finallys",
240 + 1,
241 + 1,
242 + RRD_ALGORITHM_INCREMENTAL);
243 +
244 + rrdlabels_add(p->st_clrexception_finallys->rrdlabels,
245 + "process",
246 + windows_shared_buffer,
247 + RRDLABEL_SRC_AUTO);
248 + }
249 +
250 + rrddim_set_by_pointer(p->st_clrexception_finallys,
251 + p->rd_clrexception_finallys,
252 + (collected_number)p->NETFrameworkCLRExceptionFinallys.current.Data);
253 + rrdset_done(p->st_clrexception_finallys);
254 + }
255 +
256 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRExceptionTotalCatchDepth)) {
257 + if (!p->st_clrexception_total_catch_depth) {
258 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrexception_throw_to_catch_depth", windows_shared_buffer);
259 + p->st_clrexception_total_catch_depth = rrdset_create_localhost("netframework"
260 + , id, NULL
261 + , "exceptions"
262 + , "netframework.clrexception_throw_to_catch_depth"
263 + , "Traversed stack frames"
264 + , "stack_frames/s"
265 + , PLUGIN_WINDOWS_NAME
266 + , "PerflibNetFramework"
267 + , PRIO_NETFRAMEWORK_CLR_EXCEPTION_THROW_TO_CATCH_DEPTH
268 + , update_every
269 + , RRDSET_TYPE_LINE
270 + );
271 +
272 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrexception_throw_to_catch_depth_total", windows_shared_buffer);
273 + p->rd_clrexception_total_catch_depth = rrddim_add(p->st_clrexception_total_catch_depth,
274 + id,
275 + "traversed",
276 + 1,
277 + 1,
278 + RRD_ALGORITHM_INCREMENTAL);
279 +
280 + rrdlabels_add(p->st_clrexception_total_catch_depth->rrdlabels,
281 + "process",
282 + windows_shared_buffer,
283 + RRDLABEL_SRC_AUTO);
284 + }
285 +
286 + rrddim_set_by_pointer(p->st_clrexception_total_catch_depth,
287 + p->rd_clrexception_total_catch_depth,
288 + (collected_number)p->NETFrameworkCLRExceptionTotalCatchDepth.current.Data);
289 + rrdset_done(p->st_clrexception_total_catch_depth);
290 + }
291 + }
292 +}
293 +
294 +static void netdata_framework_clr_interop(PERF_DATA_BLOCK *pDataBlock,
295 + PERF_OBJECT_TYPE *pObjectType,
296 + int update_every)
297 +{
298 + PERF_INSTANCE_DEFINITION *pi = NULL;
299 + char id[RRD_ID_LENGTH_MAX + 1];
300 + for(LONG i = 0; i < pObjectType->NumInstances ; i++) {
301 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
302 + if (!pi)
303 + break;
304 +
305 + if(!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))
306 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
307 +
308 + if(strcasecmp(windows_shared_buffer, "_Global_") == 0)
309 + continue;
310 +
311 + netdata_fix_chart_name(windows_shared_buffer);
312 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));
313 +
314 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRInteropCOMCallableWrappers)) {
315 + if (!p->st_clrinterop_com_callable_wrappers) {
316 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrinterop_com_callable_wrappers", windows_shared_buffer);
317 + p->st_clrinterop_com_callable_wrappers = rrdset_create_localhost("netframework"
318 + , id, NULL
319 + , "interop"
320 + , "netframework.clrinterop_com_callable_wrappers"
321 + , "COM callable wrappers (CCW)"
322 + , "ccw/s"
323 + , PLUGIN_WINDOWS_NAME
324 + , "PerflibNetFramework"
325 + , PRIO_NETFRAMEWORK_CLR_INTEROP_CCW
326 + , update_every
327 + , RRDSET_TYPE_LINE
328 + );
329 +
330 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrinterop_com_callable_wrappers_total", windows_shared_buffer);
331 + p->rd_clrinterop_com_callable_wrappers = rrddim_add(p->st_clrinterop_com_callable_wrappers,
332 + id,
333 + "com_callable_wrappers",
334 + 1,
335 + 1,
336 + RRD_ALGORITHM_INCREMENTAL);
337 +
338 + rrdlabels_add(p->st_clrinterop_com_callable_wrappers->rrdlabels,
339 + "process",
340 + windows_shared_buffer,
341 + RRDLABEL_SRC_AUTO);
342 + }
343 +
344 + rrddim_set_by_pointer(p->st_clrinterop_com_callable_wrappers,
345 + p->rd_clrinterop_com_callable_wrappers,
346 + (collected_number)p->NETFrameworkCLRInteropCOMCallableWrappers.current.Data);
347 + rrdset_done(p->st_clrinterop_com_callable_wrappers);
348 + }
349 +
350 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRInteropMarshalling)) {
351 + if (!p->st_clrinterop_marshalling) {
352 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrinterop_interop_marshalling", windows_shared_buffer);
353 + p->st_clrinterop_marshalling = rrdset_create_localhost("netframework"
354 + , id, NULL
355 + , "interop"
356 + , "netframework.clrinterop_interop_marshallings"
357 + , "Arguments and return values marshallings"
358 + , "marshalling/s"
359 + , PLUGIN_WINDOWS_NAME
360 + , "PerflibNetFramework"
361 + , PRIO_NETFRAMEWORK_CLR_INTEROP_MARSHALLING
362 + , update_every
363 + , RRDSET_TYPE_LINE
364 + );
365 +
366 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrinterop_interop_marshalling_total", windows_shared_buffer);
367 + p->rd_clrinterop_marshalling = rrddim_add(p->st_clrinterop_marshalling,
368 + id,
369 + "marshallings",
370 + 1,
371 + 1,
372 + RRD_ALGORITHM_INCREMENTAL);
373 +
374 + rrdlabels_add(p->st_clrinterop_marshalling->rrdlabels,
375 + "process",
376 + windows_shared_buffer,
377 + RRDLABEL_SRC_AUTO);
378 + }
379 +
380 + rrddim_set_by_pointer(p->st_clrinterop_marshalling,
381 + p->rd_clrinterop_marshalling,
382 + (collected_number)p->NETFrameworkCLRInteropMarshalling.current.Data);
383 + rrdset_done(p->st_clrinterop_marshalling);
384 + }
385 +
386 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRInteropStubsCreated)) {
387 + if (!p->st_clrinterop_interop_stubs_created) {
388 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrinterop_interop_stubs_created", windows_shared_buffer);
389 + p->st_clrinterop_interop_stubs_created = rrdset_create_localhost("netframework"
390 + , id, NULL
391 + , "interop"
392 + , "netframework.clrinterop_interop_stubs_created"
393 + , "Created stubs"
394 + , "stubs/s"
395 + , PLUGIN_WINDOWS_NAME
396 + , "PerflibNetFramework"
397 + , PRIO_NETFRAMEWORK_CLR_INTEROP_STUBS_CREATED
398 + , update_every
399 + , RRDSET_TYPE_LINE
400 + );
401 +
402 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrinterop_interop_stubs_created_total", windows_shared_buffer);
403 + p->rd_clrinterop_interop_stubs_created = rrddim_add(p->st_clrinterop_interop_stubs_created,
404 + id,
405 + "created",
406 + 1,
407 + 1,
408 + RRD_ALGORITHM_INCREMENTAL);
409 +
410 + rrdlabels_add(p->st_clrinterop_interop_stubs_created->rrdlabels,
411 + "process",
412 + windows_shared_buffer,
413 + RRDLABEL_SRC_AUTO);
414 + }
415 +
416 + rrddim_set_by_pointer(p->st_clrinterop_interop_stubs_created,
417 + p->rd_clrinterop_interop_stubs_created,
418 + (collected_number)p->NETFrameworkCLRInteropStubsCreated.current.Data);
419 + rrdset_done(p->st_clrinterop_interop_stubs_created);
420 + }
421 + }
422 +}
423 +
424 +static void netdata_framework_clr_jit(PERF_DATA_BLOCK *pDataBlock,
425 + PERF_OBJECT_TYPE *pObjectType,
426 + int update_every)
427 +{
428 + PERF_INSTANCE_DEFINITION *pi = NULL;
429 + char id[RRD_ID_LENGTH_MAX + 1];
430 + for(LONG i = 0; i < pObjectType->NumInstances ; i++) {
431 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
432 + if (!pi)
433 + break;
434 +
435 + if(!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))
436 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
437 +
438 + if(strcasecmp(windows_shared_buffer, "_Global_") == 0)
439 + continue;
440 +
441 + netdata_fix_chart_name(windows_shared_buffer);
442 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));
443 +
444 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRJITMethods)) {
445 + if (!p->st_clrjit_methods) {
446 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrjit_methods", windows_shared_buffer);
447 + p->st_clrjit_methods = rrdset_create_localhost("netframework"
448 + , id, NULL
449 + , "jit"
450 + , "netframework.clrjit_methods"
451 + , "JIT-compiled methods"
452 + , "methods/s"
453 + , PLUGIN_WINDOWS_NAME
454 + , "PerflibNetFramework"
455 + , PRIO_NETFRAMEWORK_CLR_JIT_METHODS
456 + , update_every
457 + , RRDSET_TYPE_LINE
458 + );
459 +
460 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrjit_methods_total", windows_shared_buffer);
461 + p->rd_clrjit_methods = rrddim_add(p->st_clrjit_methods,
462 + id,
463 + "jit-compiled",
464 + 1,
465 + 1,
466 + RRD_ALGORITHM_INCREMENTAL);
467 +
468 + rrdlabels_add(p->st_clrjit_methods->rrdlabels,
469 + "process",
470 + windows_shared_buffer,
471 + RRDLABEL_SRC_AUTO);
472 + }
473 +
474 + rrddim_set_by_pointer(p->st_clrjit_methods,
475 + p->rd_clrjit_methods,
476 + (collected_number)p->NETFrameworkCLRJITMethods.current.Data);
477 + rrdset_done(p->st_clrjit_methods);
478 + }
479 +
480 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRJITFrequencyTime) &&
481 + perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRJITPercentTime)) {
482 + if (!p->st_clrjit_time) {
483 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrjit_time", windows_shared_buffer);
484 + p->st_clrjit_time = rrdset_create_localhost("netframework"
485 + , id, NULL
486 + , "jit"
487 + , "netframework.clrjit_time"
488 + , "Time spent in JIT compilation"
489 + , "percentage"
490 + , PLUGIN_WINDOWS_NAME
491 + , "PerflibNetFramework"
492 + , PRIO_NETFRAMEWORK_CLR_JIT_TIME
493 + , update_every
494 + , RRDSET_TYPE_LINE
495 + );
496 +
497 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrjit_time_percent", windows_shared_buffer);
498 + p->rd_clrjit_time = rrddim_add(p->st_clrjit_time,
499 + id,
500 + "time",
501 + 1,
502 + 100,
503 + RRD_ALGORITHM_ABSOLUTE);
504 +
505 + rrdlabels_add(p->st_clrjit_time->rrdlabels,
506 + "process",
507 + windows_shared_buffer,
508 + RRDLABEL_SRC_AUTO);
509 + }
510 +
511 + double percTime = (double) p->NETFrameworkCLRJITPercentTime.current.Data;
512 + percTime /= (double) p->NETFrameworkCLRJITFrequencyTime.current.Data;
513 + percTime *= 100;
514 + rrddim_set_by_pointer(p->st_clrjit_time,
515 + p->rd_clrjit_time,
516 + (collected_number) percTime);
517 + rrdset_done(p->st_clrjit_time);
518 + }
519 +
520 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRJITStandardFailures)) {
521 + if (!p->st_clrjit_standard_failures) {
522 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrjit_standard_failures", windows_shared_buffer);
523 + p->st_clrjit_standard_failures = rrdset_create_localhost("netframework"
524 + , id, NULL
525 + , "jit"
526 + , "netframework.clrjit_standard_failures"
527 + , "JIT compiler failures"
528 + , "failures/s"
529 + , PLUGIN_WINDOWS_NAME
530 + , "PerflibNetFramework"
531 + , PRIO_NETFRAMEWORK_CLR_JIT_STANDARD_FAILURES
532 + , update_every
533 + , RRDSET_TYPE_LINE
534 + );
535 +
536 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrjit_standard_failures_total", windows_shared_buffer);
537 + p->rd_clrjit_standard_failures = rrddim_add(p->st_clrjit_standard_failures,
538 + id,
539 + "failures",
540 + 1,
541 + 1,
542 + RRD_ALGORITHM_INCREMENTAL);
543 +
544 + rrdlabels_add(p->st_clrjit_standard_failures->rrdlabels,
545 + "process",
546 + windows_shared_buffer,
547 + RRDLABEL_SRC_AUTO);
548 + }
549 +
550 + rrddim_set_by_pointer(p->st_clrjit_standard_failures,
551 + p->rd_clrjit_standard_failures,
552 + (collected_number)p->NETFrameworkCLRJITStandardFailures.current.Data);
553 + rrdset_done(p->st_clrjit_standard_failures);
554 + }
555 +
556 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRJITIlBytes)) {
557 + if (!p->st_clrjit_il_bytes) {
558 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrjit_il_bytes", windows_shared_buffer);
559 + p->st_clrjit_il_bytes = rrdset_create_localhost("netframework"
560 + , id, NULL
561 + , "jit"
562 + , "netframework.clrjit_il_bytes"
563 + , "Compiled Microsoft intermediate language (MSIL) bytes"
564 + , "bytes/s"
565 + , PLUGIN_WINDOWS_NAME
566 + , "PerflibNetFramework"
567 + , PRIO_NETFRAMEWORK_CLR_JIT_IL_BYTES
568 + , update_every
569 + , RRDSET_TYPE_LINE
570 + );
571 +
572 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrjit_il_bytes_total", windows_shared_buffer);
573 + p->rd_clrjit_il_bytes = rrddim_add(p->st_clrjit_il_bytes,
574 + id,
575 + "compiled_msil",
576 + 1,
577 + 1,
578 + RRD_ALGORITHM_INCREMENTAL);
579 +
580 + rrdlabels_add(p->st_clrjit_il_bytes->rrdlabels,
581 + "process",
582 + windows_shared_buffer,
583 + RRDLABEL_SRC_AUTO);
584 + }
585 +
586 + rrddim_set_by_pointer(p->st_clrjit_il_bytes,
587 + p->rd_clrjit_il_bytes,
588 + (collected_number)p->NETFrameworkCLRJITIlBytes.current.Data);
589 + rrdset_done(p->st_clrjit_il_bytes);
590 + }
591 + }
592 +}
593 +
594 +static void netdata_framework_clr_loading(PERF_DATA_BLOCK *pDataBlock,
595 + PERF_OBJECT_TYPE *pObjectType,
596 + int update_every)
597 +{
598 + char id[RRD_ID_LENGTH_MAX + 1];
599 + PERF_INSTANCE_DEFINITION *pi = NULL;
600 + for(LONG i = 0; i < pObjectType->NumInstances ; i++) {
601 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);
602 + if (!pi)
603 + break;
604 +
605 + if(!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))
606 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);
607 +
608 + if(strcasecmp(windows_shared_buffer, "_Global_") == 0)
609 + continue;
610 +
611 + netdata_fix_chart_name(windows_shared_buffer);
612 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));
613 +
614 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLoadingHeapSize)) {
615 + if (!p->st_clrloading_heap_size) {
616 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrloading_loader_heap_size", windows_shared_buffer);
617 + p->st_clrloading_heap_size = rrdset_create_localhost("netframework"
618 + , id, NULL
619 + , "loading"
620 + , "netframework.clrloading_loader_heap_size"
621 + , "Memory committed by class loader"
622 + , "bytes"
623 + , PLUGIN_WINDOWS_NAME
624 + , "PerflibNetFramework"
625 + , PRIO_NETFRAMEWORK_CLR_LOADING_HEAP_SIZE
626 + , update_every
627 + , RRDSET_TYPE_LINE
628 + );
629 +
630 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrloading_loader_heap_size_bytes", windows_shared_buffer);
631 + p->rd_clrloading_heap_size = rrddim_add(p->st_clrloading_heap_size,
632 + id,
633 + "committed",
634 + 1,
635 + 1,
636 + RRD_ALGORITHM_ABSOLUTE);
637 +
638 + rrdlabels_add(p->st_clrloading_heap_size->rrdlabels,
639 + "process",
640 + windows_shared_buffer,
641 + RRDLABEL_SRC_AUTO);
642 + }
643 +
644 + rrddim_set_by_pointer(p->st_clrloading_heap_size,
645 + p->rd_clrloading_heap_size,
646 + (collected_number)p->NETFrameworkCLRLoadingHeapSize.current.Data);
647 + rrdset_done(p->st_clrloading_heap_size);
648 + }
649 +
650 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLoadingAppDomainsLoaded)) {
651 + if (!p->st_clrloading_app_domains_loaded) {
652 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrloading_appdomains_loaded", windows_shared_buffer);
653 + p->st_clrloading_app_domains_loaded = rrdset_create_localhost("netframework"
654 + , id, NULL
655 + , "loading"
656 + , "netframework.clrloading_appdomains_loaded"
657 + , "Loaded application domains"
658 + , "domain/s"
659 + , PLUGIN_WINDOWS_NAME
660 + , "PerflibNetFramework"
661 + , PRIO_NETFRAMEWORK_CLR_LOADING_APP_DOMAINS_LOADED
662 + , update_every
663 + , RRDSET_TYPE_LINE
664 + );
665 +
666 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrloading_appdomains_loaded_total", windows_shared_buffer);
667 + p->rd_clrloading_app_domains_loaded = rrddim_add(p->st_clrloading_app_domains_loaded,
668 + id,
669 + "loaded",
670 + 1,
671 + 1,
672 + RRD_ALGORITHM_INCREMENTAL);
673 +
674 + rrdlabels_add(p->st_clrloading_app_domains_loaded->rrdlabels,
675 + "process",
676 + windows_shared_buffer,
677 + RRDLABEL_SRC_AUTO);
678 + }
679 +
680 + rrddim_set_by_pointer(p->st_clrloading_app_domains_loaded,
681 + p->rd_clrloading_app_domains_loaded,
682 + (collected_number)p->NETFrameworkCLRLoadingAppDomainsLoaded.current.Data);
683 + rrdset_done(p->st_clrloading_app_domains_loaded);
684 + }
685 +
686 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLoadingAppDomainsUnloaded)) {
687 + if (!p->st_clrloading_app_domains_unloaded) {
688 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrloading_appdomains_unloaded", windows_shared_buffer);
689 + p->st_clrloading_app_domains_unloaded = rrdset_create_localhost("netframework"
690 + , id, NULL
691 + , "loading"
692 + , "netframework.clrloading_appdomains_unloaded"
693 + , "Unloaded application domains"
694 + , "domain/s"
695 + , PLUGIN_WINDOWS_NAME
696 + , "PerflibNetFramework"
697 + , PRIO_NETFRAMEWORK_CLR_LOADING_APP_DOMAINS_UNLOADED
698 + , update_every
699 + , RRDSET_TYPE_LINE
700 + );
701 +
702 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrloading_appdomains_unloaded_total", windows_shared_buffer);
703 + p->rd_clrloading_app_domains_unloaded = rrddim_add(p->st_clrloading_app_domains_unloaded,
704 + id,
705 + "unloaded",
706 + 1,
707 + 1,
708 + RRD_ALGORITHM_INCREMENTAL);
709 +
710 + rrdlabels_add(p->st_clrloading_app_domains_unloaded->rrdlabels,
711 + "process",
712 + windows_shared_buffer,
713 + RRDLABEL_SRC_AUTO);
714 + }
715 +
716 + rrddim_set_by_pointer(p->st_clrloading_app_domains_unloaded,
717 + p->rd_clrloading_app_domains_unloaded,
718 + (collected_number)p->NETFrameworkCLRLoadingAppDomainsUnloaded.current.Data);
719 + rrdset_done(p->st_clrloading_app_domains_unloaded);
720 + }
721 +
722 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLoadingAssembliesLoaded)) {
723 + if (!p->st_clrloading_assemblies_loaded) {
724 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrloading_assemblies_loaded", windows_shared_buffer);
725 + p->st_clrloading_assemblies_loaded = rrdset_create_localhost("netframework"
726 + , id, NULL
727 + , "loading"
728 + , "netframework.clrloading_assemblies_loaded"
729 + , "Loaded assemblies"
730 + , "assemblies/s"
731 + , PLUGIN_WINDOWS_NAME
732 + , "PerflibNetFramework"
733 + , PRIO_NETFRAMEWORK_CLR_LOADING_ASSEMBLIES_LOADED
734 + , update_every
735 + , RRDSET_TYPE_LINE
736 + );
737 +
738 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrloading_assemblies_loaded_total", windows_shared_buffer);
739 + p->rd_clrloading_assemblies_loaded = rrddim_add(p->st_clrloading_assemblies_loaded,
740 + id,
741 + "loaded",
742 + 1,
743 + 1,
744 + RRD_ALGORITHM_INCREMENTAL);
745 +
746 + rrdlabels_add(p->st_clrloading_assemblies_loaded->rrdlabels,
747 + "process",
748 + windows_shared_buffer,
749 + RRDLABEL_SRC_AUTO);
750 + }
751 +
752 + rrddim_set_by_pointer(p->st_clrloading_assemblies_loaded,
753 + p->rd_clrloading_assemblies_loaded,
754 + (collected_number)p->NETFrameworkCLRLoadingAssembliesLoaded.current.Data);
755 + rrdset_done(p->st_clrloading_assemblies_loaded);
756 + }
757 +
758 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLoadingClassesLoaded)) {
759 + if (!p->st_clrloading_classes_loaded) {
760 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrloading_classes_loaded", windows_shared_buffer);
761 + p->st_clrloading_classes_loaded = rrdset_create_localhost("netframework"
762 + , id, NULL
763 + , "loading"
764 + , "netframework.clrloading_classes_loaded"
765 + , "Loaded classes in all assemblies"
766 + , "classes/s"
767 + , PLUGIN_WINDOWS_NAME
768 + , "PerflibNetFramework"
769 + , PRIO_NETFRAMEWORK_CLR_LOADING_CLASSES_LOADED
770 + , update_every
771 + , RRDSET_TYPE_LINE
772 + );
773 +
774 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrloading_classes_loaded_total", windows_shared_buffer);
775 + p->rd_clrloading_classes_loaded = rrddim_add(p->st_clrloading_classes_loaded,
776 + id,
777 + "loaded",
778 + 1,
779 + 1,
780 + RRD_ALGORITHM_INCREMENTAL);
781 +
782 + rrdlabels_add(p->st_clrloading_classes_loaded->rrdlabels,
783 + "process",
784 + windows_shared_buffer,
785 + RRDLABEL_SRC_AUTO);
786 + }
787 +
788 + rrddim_set_by_pointer(p->st_clrloading_classes_loaded,
789 + p->rd_clrloading_classes_loaded,
790 + (collected_number)p->NETFrameworkCLRLoadingClassesLoaded.current.Data);
791 + rrdset_done(p->st_clrloading_classes_loaded);
792 + }
793 +
794 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLoadingClassLoadFailure)) {
795 + if (!p->st_clrloading_class_load_failure) {
796 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrloading_class_load_failure", windows_shared_buffer);
797 + p->st_clrloading_class_load_failure = rrdset_create_localhost("netframework"
798 + , id, NULL
799 + , "loading"
800 + , "netframework.clrloading_class_load_failures"
801 + , "Class load failures"
802 + , "failures/s"
803 + , PLUGIN_WINDOWS_NAME
804 + , "PerflibNetFramework"
805 + , PRIO_NETFRAMEWORK_CLR_LOADING_CLASS_LOAD_FAILURE
806 + , update_every
807 + , RRDSET_TYPE_LINE
808 + );
809 +
810 + snprintfz(id, RRD_ID_LENGTH_MAX, "netframework_%s_clrloading_class_load_failures_total", windows_shared_buffer);
811 + p->rd_clrloading_class_load_failure = rrddim_add(p->st_clrloading_class_load_failure,
812 + id,
813 + "class_load",
814 + 1,
815 + 1,
816 + RRD_ALGORITHM_INCREMENTAL);
817 +
818 + rrdlabels_add(p->st_clrloading_class_load_failure->rrdlabels,
819 + "process",
820 + windows_shared_buffer,
821 + RRDLABEL_SRC_AUTO);
822 + }
823 +
824 + rrddim_set_by_pointer(p->st_clrloading_class_load_failure,
825 + p->rd_clrloading_class_load_failure,
826 + (collected_number)p->NETFrameworkCLRLoadingClassLoadFailure.current.Data);
827 + rrdset_done(p->st_clrloading_class_load_failure);
828 + }
829 + }
830 +}
831 +
832 +struct netdata_netframework_objects {
833 + char *object;
834 + void (*fnct)(PERF_DATA_BLOCK *, PERF_OBJECT_TYPE *, int);
835 +} netframewrk_obj[NETDATA_NETFRAMEWORK_END] = {
836 + {
837 + .fnct = netdata_framework_clr_exceptions,
838 + .object = ".NET CLR Exceptions"
839 + },
840 + {
841 + .fnct = netdata_framework_clr_interop,
842 + .object = ".NET CLR Interop"
843 + },
844 + {
845 + .fnct = netdata_framework_clr_jit,
846 + .object = ".NET CLR Jit"
847 + },
848 + {
849 + .fnct = netdata_framework_clr_loading,
850 + .object = ".NET CLR Loading"
851 + }
852 +};
853 +
854 +int do_PerflibNetFramework(int update_every, usec_t dt __maybe_unused) {
855 + static bool initialized = false;
856 +
857 + if(unlikely(!initialized)) {
858 + initialize();
859 + initialized = true;
860 + }
861 +
862 + int i;
863 + for (i = 0; i < NETDATA_NETFRAMEWORK_END; i++) {
864 + DWORD id = RegistryFindIDByName(netframewrk_obj[i].object);
865 + if(id == PERFLIB_REGISTRY_NAME_NOT_FOUND)
866 + continue;
867 +
868 + PERF_DATA_BLOCK *pDataBlock = perflibGetPerformanceData(id);
869 + if(!pDataBlock) continue;
870 +
871 + PERF_OBJECT_TYPE *pObjectType = perflibFindObjectTypeByName(pDataBlock, netframewrk_obj[i].object);
872 + if(!pObjectType) continue;
873 +
874 + netframewrk_obj[i].fnct(pDataBlock, pObjectType, update_every);
875 + }
876 +
877 + return 0;
878 +}
src/collectors/windows.plugin/windows_plugin.c
+14 -12
@@ -13,23 +13,25 @@ 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},
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},
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
29 - {.name = "PerflibThermalZone", .dim = "PerflibThermalZone", .enabled = CONFIG_BOOLEAN_NO, .func = do_PerflibThermalZone},
29 + {.name = "PerflibThermalZone", .dim = "PerflibThermalZone", .enabled = CONFIG_BOOLEAN_NO, .func = do_PerflibThermalZone},
30
31 - {.name = "PerflibWebService", .dim = "PerflibWebService", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibWebService},
32 - {.name = "PerflibMSSQL", .dim = "PerflibMSSQL", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibMSSQL},
31 + {.name = "PerflibWebService", .dim = "PerflibWebService", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibWebService},
32 + {.name = "PerflibMSSQL", .dim = "PerflibMSSQL", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibMSSQL},
33 +
34 + {.name = "PerflibNetFramework", .dim = "PerflibNetFramework", .enabled = CONFIG_BOOLEAN_YES, .func = do_PerflibNetFramework},
35
36 // the terminator of this array
37 {.name = NULL, .dim = NULL, .func = NULL}
src/collectors/windows.plugin/windows_plugin.h
+23 -1
@@ -27,6 +27,7 @@ int do_PerflibObjects(int update_every, usec_t dt);
27 int do_PerflibThermalZone(int update_every, usec_t dt);
28 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
32 enum PERFLIB_PRIO {
33 PRIO_WEBSITE_IIS_TRAFFIC = 21000, // PRIO selected, because APPS is using 20YYY
@@ -74,7 +75,28 @@ enum PERFLIB_PRIO {
75 PRIO_MSSQL_LOCKS_WAIT,
76 PRIO_MSSQL_LOCKS_DEADLOCK,
77
77 - PRIO_MSSQL_SQL_ERRORS
78 + PRIO_MSSQL_SQL_ERRORS,
79 +
80 + PRIO_NETFRAMEWORK_CLR_EXCEPTION_THROWN,
81 + PRIO_NETFRAMEWORK_CLR_EXCEPTION_FILTERS,
82 + PRIO_NETFRAMEWORK_CLR_EXCEPTION_FINALLYS,
83 + PRIO_NETFRAMEWORK_CLR_EXCEPTION_THROW_TO_CATCH_DEPTH,
84 +
85 + PRIO_NETFRAMEWORK_CLR_INTEROP_CCW,
86 + PRIO_NETFRAMEWORK_CLR_INTEROP_MARSHALLING,
87 + PRIO_NETFRAMEWORK_CLR_INTEROP_STUBS_CREATED,
88 +
89 + PRIO_NETFRAMEWORK_CLR_JIT_METHODS,
90 + PRIO_NETFRAMEWORK_CLR_JIT_TIME,
91 + PRIO_NETFRAMEWORK_CLR_JIT_STANDARD_FAILURES,
92 + PRIO_NETFRAMEWORK_CLR_JIT_IL_BYTES,
93 +
94 + PRIO_NETFRAMEWORK_CLR_LOADING_HEAP_SIZE,
95 + PRIO_NETFRAMEWORK_CLR_LOADING_APP_DOMAINS_LOADED,
96 + PRIO_NETFRAMEWORK_CLR_LOADING_APP_DOMAINS_UNLOADED,
97 + PRIO_NETFRAMEWORK_CLR_LOADING_ASSEMBLIES_LOADED,
98 + PRIO_NETFRAMEWORK_CLR_LOADING_CLASSES_LOADED,
99 + PRIO_NETFRAMEWORK_CLR_LOADING_CLASS_LOAD_FAILURE
100 };
101
102 #endif //NETDATA_WINDOWS_PLUGIN_H