6bac7e728 · cryptotaxi247/netdata-1

@@ -8,6 +8,9 @@ enum netdata_netframework_metrics {

8 NETDATA_NETFRAMEWORK_INTEROP,

9 NETDATA_NETFRAMEWORK_JIT,

10 NETDATA_NETFRAMEWORK_LOADING,

11 + NETDATA_NETFRAMEWORK_REMOTING,

12 + NETDATA_NETFRAMEWORK_SECURITY,

13 + NETDATA_NETFRAMEWORK_LOCKS_THREADS,

14

15 NETDATA_NETFRAMEWORK_END

16 };

@@ -64,6 +67,51 @@ struct net_framework_instances {

67 RRDSET *st_clrloading_class_load_failure;

68 RRDDIM *rd_clrloading_class_load_failure;

69

70 + RRDSET *st_clrremoting_channels;

71 + RRDDIM *rd_clrremoting_channels;

72 +

73 + RRDSET *st_clrremoting_context_bound_classes_loaded;

74 + RRDDIM *rd_clrremoting_context_bound_classes_loaded;

75 +

76 + RRDSET *st_clrremoting_context_bound_objects;

77 + RRDDIM *rd_clrremoting_context_bound_objects;

78 +

79 + RRDSET *st_clrremoting_context_proxies;

80 + RRDDIM *rd_clrremoting_context_proxies;

81 +

82 + RRDSET *st_clrremoting_contexts;

83 + RRDDIM *rd_clrremoting_contexts;

84 +

85 + RRDSET *st_clrremoting_remote_calls;

86 + RRDDIM *rd_clrremoting_remote_calls;

87 +

88 + RRDSET *st_clrsecurity_link_time_checks;

89 + RRDDIM *rd_clrsecurity_link_time_checks;

90 +

91 + RRDSET *st_clrsecurity_rt_checks_time;

92 + RRDDIM *rd_clrsecurity_rt_checks_time;

93 +

94 + RRDSET *st_clrsecurity_stack_walk_depth;

95 + RRDDIM *rd_clrsecurity_stack_walk_depth;

96 +

97 + RRDSET *st_clrsecurity_run_time_checks;

98 + RRDDIM *rd_clrsecurity_run_time_checks;

99 +

100 + RRDSET *st_clrlocksandthreads_queue_length;

101 + RRDDIM *rd_locksandthreads_queue_length;

102 +

103 + RRDSET *st_clrlocksandthreads_current_logical_threads;

104 + RRDDIM *rd_locksandthreads_current_logical_threads;

105 +

106 + RRDSET *st_clrlocksandthreads_current_physical_threads;

107 + RRDDIM *rd_locksandthreads_current_physical_threads;

108 +

109 + RRDSET *st_clrlocksandthreads_recognized_threads;

110 + RRDDIM *rd_locksandthreads_recognized_threads;

111 +

112 + RRDSET *st_clrlocksandthreads_contentions;

113 + RRDDIM *rd_locksandthreads_contentions;

114 +

115 COUNTER_DATA NETFrameworkCLRExceptionThrown;

116 COUNTER_DATA NETFrameworkCLRExceptionFilters;

117 COUNTER_DATA NETFrameworkCLRExceptionFinallys;

@@ -85,6 +133,25 @@ struct net_framework_instances {

133 COUNTER_DATA NETFrameworkCLRLoadingAssembliesLoaded;

134 COUNTER_DATA NETFrameworkCLRLoadingClassesLoaded;

135 COUNTER_DATA NETFrameworkCLRLoadingClassLoadFailure;

136 +

137 + COUNTER_DATA NETFrameworkCLRRemotingChannels;

138 + COUNTER_DATA NETFrameworkCLRRemotingContextBoundClassesLoaded;

139 + COUNTER_DATA NETFrameworkCLRRemotingContextBoundObjects;

140 + COUNTER_DATA NETFrameworkCLRRemotingContextProxies;

141 + COUNTER_DATA NETFrameworkCLRRemotingContexts;

142 + COUNTER_DATA NETFrameworkCLRRemotingRemoteCalls;

143 +

144 + COUNTER_DATA NETFrameworkCLRSecurityLinkTimeChecks;

145 + COUNTER_DATA NETFrameworkCLRSecurityPercentTimeinRTChecks;

146 + COUNTER_DATA NETFrameworkCLRSecurityFrequency_PerfTime;

147 + COUNTER_DATA NETFrameworkCLRSecurityStackWalkDepth;

148 + COUNTER_DATA NETFrameworkCLRSecurityRunTimeChecks;

149 +

150 + COUNTER_DATA NETFrameworkCLRLocksAndThreadsQueueLength;

151 + COUNTER_DATA NETFrameworkCLRLocksAndThreadsCurrentLogicalThreads;

152 + COUNTER_DATA NETFrameworkCLRLocksAndThreadsCurrentPhysicalThreads;

153 + COUNTER_DATA NETFrameworkCLRLocksAndThreadsRecognizedThreads;

154 + COUNTER_DATA NETFrameworkCLRLocksAndThreadsContentions;

155 };

156

157 static inline void initialize_net_framework_processes_keys(struct net_framework_instances *p) {

@@ -109,6 +176,25 @@ static inline void initialize_net_framework_processes_keys(struct net_framework_

176 p->NETFrameworkCLRLoadingAssembliesLoaded.key = "Total Assemblies";

177 p->NETFrameworkCLRLoadingClassesLoaded.key = "Total Classes Loaded";

178 p->NETFrameworkCLRLoadingClassLoadFailure.key = "Total # of Load Failures";

179 +

180 + p->NETFrameworkCLRRemotingChannels.key = "Channels";

181 + p->NETFrameworkCLRRemotingContextBoundClassesLoaded.key = "Context-Bound Classes Loaded";

182 + p->NETFrameworkCLRRemotingContextBoundObjects.key = "Context-Bound Objects Alloc / sec";

183 + p->NETFrameworkCLRRemotingContextProxies.key = "Context Proxies";

184 + p->NETFrameworkCLRRemotingContexts.key = "Contexts";

185 + p->NETFrameworkCLRRemotingRemoteCalls.key = "Total Remote Calls";

186 +

187 + p->NETFrameworkCLRSecurityLinkTimeChecks.key = "# Link Time Checks";

188 + p->NETFrameworkCLRSecurityPercentTimeinRTChecks.key = "% Time Sig. Authenticating";

189 + p->NETFrameworkCLRSecurityFrequency_PerfTime.key = "% Time in RT checks";

190 + p->NETFrameworkCLRSecurityStackWalkDepth.key = "Stack Walk Depth";

191 + p->NETFrameworkCLRSecurityRunTimeChecks.key = "Total Runtime Checks";

192 +

193 + p->NETFrameworkCLRLocksAndThreadsQueueLength.key = "Queue Length / sec";

194 + p->NETFrameworkCLRLocksAndThreadsCurrentLogicalThreads.key = "# of current logical Threads";

195 + p->NETFrameworkCLRLocksAndThreadsCurrentPhysicalThreads.key = "# of current physical Threads";

196 + p->NETFrameworkCLRLocksAndThreadsRecognizedThreads.key = "# of total recognized threads";

197 + p->NETFrameworkCLRLocksAndThreadsContentions.key = "Total # of Contentions";

198 }

199

200 void dict_net_framework_processes_insert_cb(

@@ -758,14 +844,644 @@ static void netdata_framework_clr_loading(PERF_DATA_BLOCK *pDataBlock, PERF_OBJE

844 }

845 }

846

847 +static void netdata_framework_clr_remoting(PERF_DATA_BLOCK *pDataBlock,

848 + PERF_OBJECT_TYPE *pObjectType,

849 + int update_every)

850 +{

851 + char id[RRD_ID_LENGTH_MAX + 1];

852 + PERF_INSTANCE_DEFINITION *pi = NULL;

853 + for (LONG i = 0; i < pObjectType->NumInstances; i++) {

854 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);

855 + if (!pi)

856 + break;

857 +

858 + if (!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))

859 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);

860 +

861 + if (strcasecmp(windows_shared_buffer, "_Global_") == 0)

862 + continue;

863 +

864 + netdata_fix_chart_name(windows_shared_buffer);

865 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));

866 +

867 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingChannels)) {

868 + if (!p->st_clrremoting_channels) {

869 + 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 + );

882 +

883 + 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);

895 + }

896 +

897 + rrddim_set_by_pointer(p->st_clrremoting_channels,

898 + p->rd_clrremoting_channels,

899 + (collected_number)p->NETFrameworkCLRRemotingChannels.current.Data);

900 + rrdset_done(p->st_clrremoting_channels);

901 + }

902 +

903 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContextBoundClassesLoaded)) {

904 + if (!p->st_clrremoting_context_bound_classes_loaded) {

905 + 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);

931 + }

932 +

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

936 + rrdset_done(p->st_clrremoting_context_bound_classes_loaded);

937 + }

938 +

939 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContextBoundObjects)) {

940 + if (!p->st_clrremoting_context_bound_objects) {

941 + 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);

967 + }

968 +

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

972 + rrdset_done(p->st_clrremoting_context_bound_objects);

973 + }

974 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContextProxies)) {

975 + if (!p->st_clrremoting_context_proxies) {

976 + 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);

1002 + }

1003 +

1004 + rrddim_set_by_pointer(p->st_clrremoting_context_proxies,

1005 + p->rd_clrremoting_context_proxies,

1006 + (collected_number)p->NETFrameworkCLRRemotingContextProxies.current.Data);

1007 + rrdset_done(p->st_clrremoting_context_proxies);

1008 + }

1009 +

1010 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingContexts)) {

1011 + if (!p->st_clrremoting_contexts) {

1012 + 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 + );

1025 +

1026 + 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);

1038 + }

1039 +

1040 + rrddim_set_by_pointer(p->st_clrremoting_contexts,

1041 + p->rd_clrremoting_contexts,

1042 + (collected_number)p->NETFrameworkCLRRemotingContexts.current.Data);

1043 + rrdset_done(p->st_clrremoting_contexts);

1044 + }

1045 +

1046 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRRemotingRemoteCalls)) {

1047 + if (!p->st_clrremoting_remote_calls) {

1048 + 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);

1074 + }

1075 +

1076 + rrddim_set_by_pointer(p->st_clrremoting_remote_calls,

1077 + p->rd_clrremoting_remote_calls,

1078 + (collected_number)p->NETFrameworkCLRRemotingContexts.current.Data);

1079 + rrdset_done(p->st_clrremoting_remote_calls);

1080 + }

1081 + }

1082 +}

1083 +

1084 +static void netdata_framework_clr_security(PERF_DATA_BLOCK *pDataBlock,

1085 + PERF_OBJECT_TYPE *pObjectType,

1086 + int update_every)

1087 +{

1088 + char id[RRD_ID_LENGTH_MAX + 1];

1089 + PERF_INSTANCE_DEFINITION *pi = NULL;

1090 + for (LONG i = 0; i < pObjectType->NumInstances; i++) {

1091 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);

1092 + if (!pi)

1093 + break;

1094 +

1095 + if (!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))

1096 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);

1097 +

1098 + if (strcasecmp(windows_shared_buffer, "_Global_") == 0)

1099 + continue;

1100 +

1101 + netdata_fix_chart_name(windows_shared_buffer);

1102 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));

1103 +

1104 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityLinkTimeChecks)) {

1105 + if (!p->st_clrsecurity_link_time_checks) {

1106 + 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);

1132 + }

1133 +

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

1137 + rrdset_done(p->st_clrsecurity_link_time_checks);

1138 + }

1139 +

1140 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityPercentTimeinRTChecks) &&

1141 + perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityFrequency_PerfTime)) {

1142 + if (!p->st_clrsecurity_link_time_checks) {

1143 + 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);

1169 + }

1170 +

1171 + NETDATA_DOUBLE value = (NETDATA_DOUBLE)p->NETFrameworkCLRSecurityPercentTimeinRTChecks.current.Data;

1172 + value /= (NETDATA_DOUBLE)p->NETFrameworkCLRSecurityFrequency_PerfTime.current.Data;

1173 +

1174 + rrddim_set_by_pointer(p->st_clrsecurity_link_time_checks,

1175 + p->rd_clrsecurity_link_time_checks,

1176 + (collected_number)(value * 100.0));

1177 + rrdset_done(p->st_clrsecurity_link_time_checks);

1178 + }

1179 +

1180 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityStackWalkDepth)) {

1181 + if (!p->st_clrsecurity_stack_walk_depth) {

1182 + 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 + );

1195 +

1196 + 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);

1208 + }

1209 +

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

1213 + rrdset_done(p->st_clrsecurity_stack_walk_depth);

1214 + }

1215 +

1216 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRSecurityRunTimeChecks)) {

1217 + if (!p->st_clrsecurity_stack_walk_depth) {

1218 + 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);

1244 + }

1245 +

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

1249 + rrdset_done(p->st_clrsecurity_stack_walk_depth);

1250 + }

1251 + }

1252 +}

1253 +

1254 +static void netdata_framework_clr_locks_and_threads(PERF_DATA_BLOCK *pDataBlock,

1255 + PERF_OBJECT_TYPE *pObjectType,

1256 + int update_every)

1257 +{

1258 + char id[RRD_ID_LENGTH_MAX + 1];

1259 + PERF_INSTANCE_DEFINITION *pi = NULL;

1260 + for (LONG i = 0; i < pObjectType->NumInstances; i++) {

1261 + pi = perflibForEachInstance(pDataBlock, pObjectType, pi);

1262 + if (!pi)

1263 + break;

1264 +

1265 + if (!getInstanceName(pDataBlock, pObjectType, pi, windows_shared_buffer, sizeof(windows_shared_buffer)))

1266 + strncpyz(windows_shared_buffer, "[unknown]", sizeof(windows_shared_buffer) - 1);

1267 +

1268 + if (strcasecmp(windows_shared_buffer, "_Global_") == 0)

1269 + continue;

1270 +

1271 + netdata_fix_chart_name(windows_shared_buffer);

1272 + struct net_framework_instances *p = dictionary_set(processes, windows_shared_buffer, NULL, sizeof(*p));

1273 +

1274 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsQueueLength)) {

1275 + if (!p->st_clrlocksandthreads_queue_length) {

1276 + snprintfz(id, RRD_ID_LENGTH_MAX, "%s_clrlocksandthreads_queue_length", windows_shared_buffer);

1277 + p->st_clrlocksandthreads_queue_length = rrdset_create_localhost(

1278 + "netframework",

1279 + id,

1280 + NULL,

1281 + "locks threads",

1282 + "netframework.clrlocksandthreads_queue_length",

1283 + "Threads waited to acquire a managed lock",

1284 + "threads/s",

1285 + PLUGIN_WINDOWS_NAME,

1286 + "PerflibNetFramework",

1287 + PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_QUEUE_LENGTH,

1288 + update_every,

1289 + RRDSET_TYPE_LINE);

1290 +

1291 + snprintfz(

1292 + id,

1293 + RRD_ID_LENGTH_MAX,

1294 + "netframework_%s_clrlocksandthreads_recognized_threads_total",

1295 + windows_shared_buffer);

1296 + p->rd_locksandthreads_queue_length =

1297 + rrddim_add(p->st_clrlocksandthreads_queue_length, id, "threads", 1, 1, RRD_ALGORITHM_INCREMENTAL);

1298 +

1299 + rrdlabels_add(

1300 + p->st_clrlocksandthreads_queue_length->rrdlabels,

1301 + "process",

1302 + windows_shared_buffer,

1303 + RRDLABEL_SRC_AUTO);

1304 + }

1305 +

1306 + rrddim_set_by_pointer(

1307 + p->st_clrlocksandthreads_queue_length,

1308 + p->rd_locksandthreads_queue_length,

1309 + (collected_number)p->NETFrameworkCLRLocksAndThreadsQueueLength.current.Data);

1310 + rrdset_done(p->st_clrlocksandthreads_queue_length);

1311 + }

1312 +

1313 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsCurrentLogicalThreads)) {

1314 + if (!p->st_clrlocksandthreads_current_logical_threads) {

1315 + snprintfz(

1316 + id, RRD_ID_LENGTH_MAX, "%s_clrlocksandthreads_current_logical_threads", windows_shared_buffer);

1317 + p->st_clrlocksandthreads_current_logical_threads = rrdset_create_localhost(

1318 + "netframework",

1319 + id,

1320 + NULL,

1321 + "locks threads",

1322 + "netframework.clrlocksandthreads_current_logical_threads",

1323 + "Logical threads",

1324 + "threads",

1325 + PLUGIN_WINDOWS_NAME,

1326 + "PerflibNetFramework",

1327 + PRIO_NETFRAMEWORK_CLR_LOCKS_AND_THREADS_LOGICAL_THREADS,

1328 + update_every,

1329 + RRDSET_TYPE_LINE);

1330 +

1331 + snprintfz(

1332 + id,

1333 + RRD_ID_LENGTH_MAX,

1334 + "netframework_%s_clrlocksandthreads_current_logical_threads",

1335 + windows_shared_buffer);

1336 + p->rd_locksandthreads_current_logical_threads = rrddim_add(

1337 + p->st_clrlocksandthreads_current_logical_threads, id, "logical", 1, 1, RRD_ALGORITHM_INCREMENTAL);

1338 +

1339 + rrdlabels_add(

1340 + p->st_clrlocksandthreads_current_logical_threads->rrdlabels,

1341 + "process",

1342 + windows_shared_buffer,

1343 + RRDLABEL_SRC_AUTO);

1344 + }

1345 +

1346 + rrddim_set_by_pointer(

1347 + p->st_clrlocksandthreads_current_logical_threads,

1348 + p->rd_locksandthreads_current_logical_threads,

1349 + (collected_number)p->NETFrameworkCLRLocksAndThreadsCurrentLogicalThreads.current.Data);

1350 + rrdset_done(p->st_clrlocksandthreads_current_logical_threads);

1351 + }

1352 +

1353 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsCurrentPhysicalThreads)) {

1354 + 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);

1384 + }

1385 +

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

1389 + rrdset_done(p->st_clrlocksandthreads_current_physical_threads);

1390 + }

1391 +

1392 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsRecognizedThreads)) {

1393 + if (!p->st_clrlocksandthreads_recognized_threads) {

1394 + 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);

1423 + }

1424 +

1425 + rrddim_set_by_pointer(p->st_clrlocksandthreads_recognized_threads,

1426 + p->rd_locksandthreads_recognized_threads,

1427 + (collected_number)p->NETFrameworkCLRLocksAndThreadsRecognizedThreads.current.Data);

1428 + rrdset_done(p->st_clrlocksandthreads_recognized_threads);

1429 + }

1430 +

1431 + if (perflibGetObjectCounter(pDataBlock, pObjectType, &p->NETFrameworkCLRLocksAndThreadsContentions)) {

1432 + if (!p->st_clrlocksandthreads_contentions) {

1433 + 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);

1462 + }

1463 +

1464 + rrddim_set_by_pointer(p->st_clrlocksandthreads_contentions,

1465 + p->rd_locksandthreads_contentions,

1466 + (collected_number)p->NETFrameworkCLRLocksAndThreadsContentions.current.Data);

1467 + rrdset_done(p->st_clrlocksandthreads_contentions);

1468 + }

1469 + }

1470 +}

1471 +

1472 struct netdata_netframework_objects {

1473 char *object;

1474 void (*fnct)(PERF_DATA_BLOCK *, PERF_OBJECT_TYPE *, int);

1475 } netframewrk_obj[NETDATA_NETFRAMEWORK_END] = {

765 - {.fnct = netdata_framework_clr_exceptions, .object = ".NET CLR Exceptions"},

766 - {.fnct = netdata_framework_clr_interop, .object = ".NET CLR Interop"},

767 - {.fnct = netdata_framework_clr_jit, .object = ".NET CLR Jit"},

768 - {.fnct = netdata_framework_clr_loading, .object = ".NET CLR Loading"}};

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

1483 +

1484 +};

1485

1486 int do_PerflibNetFramework(int update_every, usec_t dt __maybe_unused) {

1487 static bool initialized = false;

Add NetFramework Metrics (part II) (#19008)