@cryptotaxi247 / netdata-1 / commits / 565d64378

Split chars (eBPF <-> Apps integration) (#16139)

thiagoftsm committed Nov 11, 2023 at 16:04 UTC 565d6437899890664308f55346fa9dadb57190ce
24 files changed +2213 -1788
collectors/ebpf.plugin/ebpf.c
+55 -86
@@ -1059,25 +1059,6 @@ collected_number get_value_from_structure(char *basis, size_t offset)
1059 return ret;
1060 }
1061
1062 -/**
1063 - * Write begin command on standard output
1064 - *
1065 - * @param family the chart family name
1066 - * @param name the chart name
1067 - */
1068 -void write_begin_chart(char *family, char *name)
1069 -{
1070 - printf("BEGIN %s.%s\n", family, name);
1071 -}
1072 -
1073 -/**
1074 - * Write END command on stdout.
1075 - */
1076 -inline void write_end_chart()
1077 -{
1078 - printf("END\n");
1079 -}
1080 -
1062 /**
1063 * Write set command on standard output
1064 *
@@ -1101,7 +1082,7 @@ void write_chart_dimension(char *dim, long long value)
1082 */
1083 void write_count_chart(char *name, char *family, netdata_publish_syscall_t *move, uint32_t end)
1084 {
1104 - write_begin_chart(family, name);
1085 + ebpf_write_begin_chart(family, name, "");
1086
1087 uint32_t i = 0;
1088 while (move && i < end) {
@@ -1111,7 +1092,7 @@ void write_count_chart(char *name, char *family, netdata_publish_syscall_t *move
1092 i++;
1093 }
1094
1114 - write_end_chart();
1095 + ebpf_write_end_chart();
1096 }
1097
1098 /**
@@ -1124,7 +1105,7 @@ void write_count_chart(char *name, char *family, netdata_publish_syscall_t *move
1105 */
1106 void write_err_chart(char *name, char *family, netdata_publish_syscall_t *move, int end)
1107 {
1127 - write_begin_chart(family, name);
1108 + ebpf_write_begin_chart(family, name, "");
1109
1110 int i = 0;
1111 while (move && i < end) {
@@ -1134,7 +1115,7 @@ void write_err_chart(char *name, char *family, netdata_publish_syscall_t *move,
1115 i++;
1116 }
1117
1137 - write_end_chart();
1118 + ebpf_write_end_chart();
1119 }
1120
1121 /**
@@ -1149,11 +1130,11 @@ void write_err_chart(char *name, char *family, netdata_publish_syscall_t *move,
1130 */
1131 void ebpf_one_dimension_write_charts(char *family, char *chart, char *dim, long long v1)
1132 {
1152 - write_begin_chart(family, chart);
1133 + ebpf_write_begin_chart(family, chart, "");
1134
1135 write_chart_dimension(dim, v1);
1136
1156 - write_end_chart();
1137 + ebpf_write_end_chart();
1138 }
1139
1140 /**
@@ -1170,19 +1151,20 @@ void ebpf_one_dimension_write_charts(char *family, char *chart, char *dim, long
1151 */
1152 void write_io_chart(char *chart, char *family, char *dwrite, long long vwrite, char *dread, long long vread)
1153 {
1173 - write_begin_chart(family, chart);
1154 + ebpf_write_begin_chart(family, chart, "");
1155
1156 write_chart_dimension(dwrite, vwrite);
1157 write_chart_dimension(dread, vread);
1158
1178 - write_end_chart();
1159 + ebpf_write_end_chart();
1160 }
1161
1162 /**
1163 * Write chart cmd on standard output
1164 *
1165 * @param type chart type
1185 - * @param id chart id
1166 + * @param id chart id (the apps group name).
1167 + * @param suffix suffix to differentiate charts
1168 * @param title chart title
1169 * @param units units label
1170 * @param family group name used to attach the chart on dashboard
@@ -1192,12 +1174,13 @@ void write_io_chart(char *chart, char *family, char *dwrite, long long vwrite, c
1174 * @param update_every update interval used by plugin
1175 * @param module chart module name, this is the eBPF thread.
1176 */
1195 -void ebpf_write_chart_cmd(char *type, char *id, char *title, char *units, char *family,
1177 +void ebpf_write_chart_cmd(char *type, char *id, char *suffix, char *title, char *units, char *family,
1178 char *charttype, char *context, int order, int update_every, char *module)
1179 {
1198 - printf("CHART %s.%s '' '%s' '%s' '%s' '%s' '%s' %d %d '' 'ebpf.plugin' '%s'\n",
1180 + printf("CHART %s.%s%s '' '%s' '%s' '%s' '%s' '%s' %d %d '' 'ebpf.plugin' '%s'\n",
1181 type,
1182 id,
1183 + suffix,
1184 title,
1185 units,
1186 (family)?family:"",
@@ -1213,6 +1196,7 @@ void ebpf_write_chart_cmd(char *type, char *id, char *title, char *units, char *
1196 *
1197 * @param type chart type
1198 * @param id chart id
1199 + * @param suffix add suffix to obsolete charts.
1200 * @param title chart title
1201 * @param units units label
1202 * @param family group name used to attach the chart on dashboard
@@ -1221,12 +1205,13 @@ void ebpf_write_chart_cmd(char *type, char *id, char *title, char *units, char *
1205 * @param order chart order
1206 * @param update_every value to overwrite the update frequency set by the server.
1207 */
1224 -void ebpf_write_chart_obsolete(char *type, char *id, char *title, char *units, char *family,
1208 +void ebpf_write_chart_obsolete(char *type, char *id, char *suffix, char *title, char *units, char *family,
1209 char *charttype, char *context, int order, int update_every)
1210 {
1227 - printf("CHART %s.%s '' '%s' '%s' '%s' '%s' '%s' %d %d 'obsolete'\n",
1211 + printf("CHART %s.%s%s '' '%s' '%s' '%s' '%s' '%s' %d %d 'obsolete'\n",
1212 type,
1213 id,
1214 + suffix,
1215 title,
1216 units,
1217 (family)?family:"",
@@ -1298,40 +1283,13 @@ void ebpf_create_chart(char *type,
1283 int update_every,
1284 char *module)
1285 {
1301 - ebpf_write_chart_cmd(type, id, title, units, family, charttype, context, order, update_every, module);
1286 + ebpf_write_chart_cmd(type, id, "", title, units, family, charttype, context, order, update_every, module);
1287
1288 if (ncd) {
1289 ncd(move, end);
1290 }
1291 }
1292
1308 -/**
1309 - * Create charts on apps submenu
1310 - *
1311 - * @param id the chart id
1312 - * @param title the value displayed on vertical axis.
1313 - * @param units the value displayed on vertical axis.
1314 - * @param family Submenu that the chart will be attached on dashboard.
1315 - * @param charttype chart type
1316 - * @param order the chart order
1317 - * @param algorithm the algorithm used by dimension
1318 - * @param root structure used to create the dimensions.
1319 - * @param update_every update interval used by plugin
1320 - * @param module chart module name, this is the eBPF thread.
1321 - */
1322 -void ebpf_create_charts_on_apps(char *id, char *title, char *units, char *family, char *charttype, int order,
1323 - char *algorithm, struct ebpf_target *root, int update_every, char *module)
1324 -{
1325 - struct ebpf_target *w;
1326 - ebpf_write_chart_cmd(NETDATA_APPS_FAMILY, id, title, units, family, charttype, NULL, order,
1327 - update_every, module);
1328 -
1329 - for (w = root; w; w = w->next) {
1330 - if (unlikely(w->exposed))
1331 - fprintf(stdout, "DIMENSION %s '' %s 1 1\n", w->name, algorithm);
1332 - }
1333 -}
1334 -
1293 /**
1294 * Call the necessary functions to create a name.
1295 *
@@ -1345,14 +1303,14 @@ void ebpf_create_charts_on_apps(char *id, char *title, char *units, char *family
1303 */
1304 void write_histogram_chart(char *family, char *name, const netdata_idx_t *hist, char **dimensions, uint32_t end)
1305 {
1348 - write_begin_chart(family, name);
1306 + ebpf_write_begin_chart(family, name, "");
1307
1308 uint32_t i;
1309 for (i = 0; i < end; i++) {
1310 write_chart_dimension(dimensions[i], (long long) hist[i]);
1311 }
1312
1355 - write_end_chart();
1313 + ebpf_write_end_chart();
1314
1315 fflush(stdout);
1316 }
@@ -1377,6 +1335,7 @@ int ebpf_statistic_create_aral_chart(char *name, ebpf_module_t *em)
1335
1336 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
1337 em->memory_usage,
1338 + "",
1339 "Bytes allocated for ARAL.",
1340 "bytes",
1341 NETDATA_EBPF_FAMILY,
@@ -1392,6 +1351,7 @@ int ebpf_statistic_create_aral_chart(char *name, ebpf_module_t *em)
1351
1352 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
1353 em->memory_allocations,
1354 + "",
1355 "Calls to allocate memory.",
1356 "calls",
1357 NETDATA_EBPF_FAMILY,
@@ -1421,6 +1381,7 @@ void ebpf_statistic_obsolete_aral_chart(ebpf_module_t *em, int prio)
1381 {
1382 ebpf_write_chart_obsolete(NETDATA_MONITORING_FAMILY,
1383 em->memory_allocations,
1384 + "",
1385 "Calls to allocate memory.",
1386 "calls",
1387 NETDATA_EBPF_FAMILY,
@@ -1431,6 +1392,7 @@ void ebpf_statistic_obsolete_aral_chart(ebpf_module_t *em, int prio)
1392
1393 ebpf_write_chart_obsolete(NETDATA_MONITORING_FAMILY,
1394 em->memory_allocations,
1395 + "",
1396 "Calls to allocate memory.",
1397 "calls",
1398 NETDATA_EBPF_FAMILY,
@@ -1455,13 +1417,13 @@ void ebpf_send_data_aral_chart(ARAL *memory, ebpf_module_t *em)
1417
1418 struct aral_statistics *stats = aral_statistics(memory);
1419
1458 - write_begin_chart(NETDATA_MONITORING_FAMILY, em->memory_usage);
1420 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, em->memory_usage, "");
1421 write_chart_dimension(mem, (long long)stats->structures.allocated_bytes);
1460 - write_end_chart();
1422 + ebpf_write_end_chart();
1423
1462 - write_begin_chart(NETDATA_MONITORING_FAMILY, em->memory_allocations);
1424 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, em->memory_allocations, "");
1425 write_chart_dimension(aral, (long long)stats->structures.allocations);
1464 - write_end_chart();
1426 + ebpf_write_end_chart();
1427 }
1428
1429 /*****************************************************************
@@ -3442,7 +3404,7 @@ static char *hash_table_core[NETDATA_EBPF_LOAD_STAT_END] = {"per_core", "unique"
3404 static inline void ebpf_send_hash_table_pid_data(char *chart, uint32_t idx)
3405 {
3406 int i;
3445 - write_begin_chart(NETDATA_MONITORING_FAMILY, chart);
3407 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, chart, "");
3408 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {
3409 ebpf_module_t *wem = &ebpf_modules[i];
3410 if (wem->functions.apps_routine)
@@ -3451,7 +3413,7 @@ static inline void ebpf_send_hash_table_pid_data(char *chart, uint32_t idx)
3413 wem->hash_table_stats[idx]:
3414 0);
3415 }
3454 - write_end_chart();
3416 + ebpf_write_end_chart();
3417 }
3418
3419 /**
@@ -3463,13 +3425,13 @@ static inline void ebpf_send_hash_table_pid_data(char *chart, uint32_t idx)
3425 static inline void ebpf_send_global_hash_table_data()
3426 {
3427 int i;
3466 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_GLOBAL_ELEMENTS);
3428 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_GLOBAL_ELEMENTS, "");
3429 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {
3430 ebpf_module_t *wem = &ebpf_modules[i];
3431 write_chart_dimension((char *)wem->info.thread_name,
3432 (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ? NETDATA_CONTROLLER_END: 0);
3433 }
3472 - write_end_chart();
3434 + ebpf_write_end_chart();
3435 }
3436
3437 /**
@@ -3482,7 +3444,7 @@ void ebpf_send_statistic_data()
3444 if (!publish_internal_metrics)
3445 return;
3446
3485 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_THREADS);
3447 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_THREADS, "");
3448 int i;
3449 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX; i++) {
3450 ebpf_module_t *wem = &ebpf_modules[i];
@@ -3491,9 +3453,9 @@ void ebpf_send_statistic_data()
3453
3454 write_chart_dimension((char *)wem->info.thread_name, (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ? 1 : 0);
3455 }
3494 - write_end_chart();
3456 + ebpf_write_end_chart();
3457
3496 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_LIFE_TIME);
3458 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_LIFE_TIME, "");
3459 for (i = 0; i < EBPF_MODULE_FUNCTION_IDX ; i++) {
3460 ebpf_module_t *wem = &ebpf_modules[i];
3461 // Threads like VFS is slow to load and this can create an invalid number, this is the motive
@@ -3506,25 +3468,25 @@ void ebpf_send_statistic_data()
3468 (long long) (wem->lifetime - wem->running_time):
3469 0) ;
3470 }
3509 - write_end_chart();
3471 + ebpf_write_end_chart();
3472
3511 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_LOAD_METHOD);
3473 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_LOAD_METHOD, "");
3474 write_chart_dimension(load_event_stat[NETDATA_EBPF_LOAD_STAT_LEGACY], (long long)plugin_statistics.legacy);
3475 write_chart_dimension(load_event_stat[NETDATA_EBPF_LOAD_STAT_CORE], (long long)plugin_statistics.core);
3514 - write_end_chart();
3476 + ebpf_write_end_chart();
3477
3516 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_KERNEL_MEMORY);
3478 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_KERNEL_MEMORY, "");
3479 write_chart_dimension(memlock_stat, (long long)plugin_statistics.memlock_kern);
3518 - write_end_chart();
3480 + ebpf_write_end_chart();
3481
3520 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_LOADED);
3482 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_LOADED, "");
3483 write_chart_dimension(hash_table_stat, (long long)plugin_statistics.hash_tables);
3522 - write_end_chart();
3484 + ebpf_write_end_chart();
3485
3524 - write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_PER_CORE);
3486 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, NETDATA_EBPF_HASH_TABLES_PER_CORE, "");
3487 write_chart_dimension(hash_table_core[NETDATA_EBPF_THREAD_PER_CORE], (long long)plugin_statistics.hash_percpu);
3488 write_chart_dimension(hash_table_core[NETDATA_EBPF_THREAD_UNIQUE], (long long)plugin_statistics.hash_unique);
3527 - write_end_chart();
3489 + ebpf_write_end_chart();
3490
3491 ebpf_send_global_hash_table_data();
3492
@@ -3536,16 +3498,16 @@ void ebpf_send_statistic_data()
3498 if (!wem->functions.fnct_routine)
3499 continue;
3500
3539 - write_begin_chart(NETDATA_MONITORING_FAMILY, (char *)wem->functions.fcnt_thread_chart_name);
3501 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, (char *)wem->functions.fcnt_thread_chart_name, "");
3502 write_chart_dimension((char *)wem->info.thread_name, (wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ? 1 : 0);
3541 - write_end_chart();
3503 + ebpf_write_end_chart();
3504
3543 - write_begin_chart(NETDATA_MONITORING_FAMILY, (char *)wem->functions.fcnt_thread_lifetime_name);
3505 + ebpf_write_begin_chart(NETDATA_MONITORING_FAMILY, (char *)wem->functions.fcnt_thread_lifetime_name, "");
3506 write_chart_dimension((char *)wem->info.thread_name,
3507 (wem->lifetime && wem->enabled < NETDATA_THREAD_EBPF_STOPPING) ?
3508 (long long) (wem->lifetime - wem->running_time):
3509 0) ;
3548 - write_end_chart();
3510 + ebpf_write_end_chart();
3511 }
3512 }
3513
@@ -3586,6 +3548,7 @@ static void ebpf_create_thread_chart(char *name,
3548 // common call for specific and all charts.
3549 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3550 name,
3551 + "",
3552 title,
3553 units,
3554 NETDATA_EBPF_FAMILY,
@@ -3625,6 +3588,7 @@ static inline void ebpf_create_statistic_load_chart(int update_every)
3588 {
3589 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3590 NETDATA_EBPF_LOAD_METHOD,
3591 + "",
3592 "Load info.",
3593 "methods",
3594 NETDATA_EBPF_FAMILY,
@@ -3654,6 +3618,7 @@ static inline void ebpf_create_statistic_kernel_memory(int update_every)
3618 {
3619 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3620 NETDATA_EBPF_KERNEL_MEMORY,
3621 + "",
3622 "Memory allocated for hash tables.",
3623 "bytes",
3624 NETDATA_EBPF_FAMILY,
@@ -3679,6 +3644,7 @@ static inline void ebpf_create_statistic_hash_tables(int update_every)
3644 {
3645 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3646 NETDATA_EBPF_HASH_TABLES_LOADED,
3647 + "",
3648 "Number of hash tables loaded.",
3649 "hash tables",
3650 NETDATA_EBPF_FAMILY,
@@ -3704,6 +3670,7 @@ static inline void ebpf_create_statistic_hash_per_core(int update_every)
3670 {
3671 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3672 NETDATA_EBPF_HASH_TABLES_PER_CORE,
3673 + "",
3674 "How threads are loading hash/array tables.",
3675 "threads",
3676 NETDATA_EBPF_FAMILY,
@@ -3733,6 +3700,7 @@ static void ebpf_create_statistic_hash_global_elements(int update_every)
3700 {
3701 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3702 NETDATA_EBPF_HASH_TABLES_GLOBAL_ELEMENTS,
3703 + "",
3704 "Controllers inside global table",
3705 "rows",
3706 NETDATA_EBPF_FAMILY,
@@ -3764,6 +3732,7 @@ static void ebpf_create_statistic_hash_pid_table(int update_every, char *id, cha
3732 {
3733 ebpf_write_chart_cmd(NETDATA_MONITORING_FAMILY,
3734 id,
3735 + "",
3736 title,
3737 "rows",
3738 NETDATA_EBPF_FAMILY,
collectors/ebpf.plugin/ebpf.h
+46 -15
@@ -238,6 +238,7 @@ void ebpf_global_labels(netdata_syscall_stat_t *is,
238
239 void ebpf_write_chart_cmd(char *type,
240 char *id,
241 + char *suffix,
242 char *title,
243 char *units,
244 char *family,
@@ -265,8 +266,6 @@ void ebpf_create_chart(char *type,
266 int update_every,
267 char *module);
268
268 -void write_begin_chart(char *family, char *name);
269 -
269 void write_chart_dimension(char *dim, long long value);
270
271 void write_count_chart(char *name, char *family, netdata_publish_syscall_t *move, uint32_t end);
@@ -276,18 +275,47 @@ void write_err_chart(char *name, char *family, netdata_publish_syscall_t *move,
275 void write_io_chart(char *chart, char *family, char *dwrite, long long vwrite,
276 char *dread, long long vread);
277
279 -void ebpf_create_charts_on_apps(char *name,
280 - char *title,
281 - char *units,
282 - char *family,
283 - char *charttype,
284 - int order,
285 - char *algorithm,
286 - struct ebpf_target *root,
287 - int update_every,
288 - char *module);
289 -
290 -void write_end_chart();
278 +/**
279 + * Create Chart labels
280 + *
281 + * @param name the label name.
282 + * @param value the label value.
283 + * @param origin the labeel source.
284 + */
285 +static inline void ebpf_create_chart_labels(char *name, char *value, int source)
286 +{
287 + fprintf(stdout, "CLABEL '%s' '%s' %d\n", name, value, source);
288 +}
289 +
290 +/**
291 + * Commit label
292 + *
293 + * Write commit label to stdout
294 + */
295 +static inline void ebpf_commit_label()
296 +{
297 + fprintf(stdout, "CLABEL_COMMIT\n");
298 +}
299 +
300 +/**
301 + * Write begin command on standard output
302 + *
303 + * @param family the chart family name
304 + * @param name the chart name
305 + * @param metric the chart suffix (used with apps and cgroups)
306 + */
307 +static inline void ebpf_write_begin_chart(char *family, char *name, char *metric)
308 +{
309 + printf("BEGIN %s.%s%s\n", family, name, metric);
310 +}
311 +
312 +/**
313 + * Write END command on stdout.
314 + */
315 +static inline void ebpf_write_end_chart()
316 +{
317 + printf("END\n");
318 +}
319
320 int ebpf_enable_tracepoint(ebpf_tracepoint_t *tp);
321 int ebpf_disable_tracepoint(ebpf_tracepoint_t *tp);
@@ -297,6 +325,9 @@ void ebpf_pid_file(char *filename, size_t length);
325
326 #define EBPF_PROGRAMS_SECTION "ebpf programs"
327
328 +#define EBPF_COMMON_DIMENSION_PERCENTAGE "%"
329 +#define EBPF_PROGRAMS_SECTION "ebpf programs"
330 +
331 #define EBPF_COMMON_DIMENSION_PERCENTAGE "%"
332 #define EBPF_COMMON_DIMENSION_CALL "calls/s"
333 #define EBPF_COMMON_DIMENSION_CONNECTIONS "connections/s"
@@ -334,7 +365,7 @@ void ebpf_cachestat_create_apps_charts(struct ebpf_module *em, void *root);
365 void ebpf_one_dimension_write_charts(char *family, char *chart, char *dim, long long v1);
366 collected_number get_value_from_structure(char *basis, size_t offset);
367 void ebpf_update_pid_table(ebpf_local_maps_t *pid, ebpf_module_t *em);
337 -void ebpf_write_chart_obsolete(char *type, char *id, char *title, char *units, char *family,
368 +void ebpf_write_chart_obsolete(char *type, char *id, char *suffix, char *title, char *units, char *family,
369 char *charttype, char *context, int order, int update_every);
370 void write_histogram_chart(char *family, char *name, const netdata_idx_t *hist, char **dimensions, uint32_t end);
371 void ebpf_update_disabled_plugin_stats(ebpf_module_t *em);
collectors/ebpf.plugin/ebpf_apps.c
+7 -10
@@ -132,16 +132,6 @@ ebpf_socket_publish_apps_t *ebpf_socket_stat_get(void)
132 return target;
133 }
134
135 -/**
136 - * eBPF socket release
137 - *
138 - * @param stat Release a target after usage.
139 - */
140 -void ebpf_socket_release(ebpf_socket_publish_apps_t *stat)
141 -{
142 - aral_freez(ebpf_aral_socket_pid, stat);
143 -}
144 -
135 /*****************************************************************
136 *
137 * CACHESTAT ARAL FUNCTIONS
@@ -512,6 +502,13 @@ struct ebpf_target *get_apps_groups_target(struct ebpf_target **agrt, const char
502 // copy the id
503 strncpyz(w->name, nid, EBPF_MAX_NAME);
504
505 + strncpyz(w->clean_name, w->name, EBPF_MAX_NAME);
506 + netdata_fix_chart_name(w->clean_name);
507 + for (char *d = w->clean_name; *d; d++) {
508 + if (*d == '.')
509 + *d = '_';
510 + }
511 +
512 strncpyz(w->compare, nid, EBPF_MAX_COMPARE_NAME);
513 size_t len = strlen(w->compare);
514 if (w->compare[len - 1] == '*') {
collectors/ebpf.plugin/ebpf_apps.h
+5 -2
@@ -10,11 +10,13 @@
10 #include "libnetdata/ebpf/ebpf.h"
11
12 #define NETDATA_APPS_FAMILY "apps"
13 +#define NETDATA_APP_FAMILY "app"
14 #define NETDATA_APPS_FILE_GROUP "file_access"
15 +#define NETDATA_APPS_FILE_FDS "fds"
16 #define NETDATA_APPS_FILE_CGROUP_GROUP "file_access (eBPF)"
17 #define NETDATA_APPS_PROCESS_GROUP "process (eBPF)"
18 #define NETDATA_APPS_NET_GROUP "net"
17 -#define NETDATA_APPS_IPC_SHM_GROUP "ipc shm (eBPF)"
19 +#define NETDATA_APPS_IPC_SHM_GROUP "ipc shm"
20
21 #include "ebpf_process.h"
22 #include "ebpf_dcstat.h"
@@ -47,8 +49,10 @@ struct ebpf_target {
49
50 char id[EBPF_MAX_NAME + 1];
51 uint32_t idhash;
52 + uint32_t charts_created;
53
54 char name[EBPF_MAX_NAME + 1];
55 + char clean_name[EBPF_MAX_NAME + 1]; // sanitized name used in chart id (need to replace at least dots)
56
57 // Changes made to simplify integration between apps and eBPF.
58 netdata_publish_cachestat_t cachestat;
@@ -218,7 +222,6 @@ extern ebpf_process_stat_t *process_stat_vector;
222 extern ARAL *ebpf_aral_socket_pid;
223 void ebpf_socket_aral_init();
224 ebpf_socket_publish_apps_t *ebpf_socket_stat_get(void);
221 -void ebpf_socket_release(ebpf_socket_publish_apps_t *stat);
225
226 extern ARAL *ebpf_aral_cachestat_pid;
227 void ebpf_cachestat_aral_init();
collectors/ebpf.plugin/ebpf_cachestat.c
+175 -128
@@ -353,6 +353,7 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
353 {
354 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
355 NETDATA_CACHESTAT_HIT_RATIO_CHART,
356 + "",
357 "Hit ratio",
358 EBPF_COMMON_DIMENSION_PERCENTAGE,
359 NETDATA_CACHESTAT_SUBMENU,
@@ -363,6 +364,7 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
364
365 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
366 NETDATA_CACHESTAT_DIRTY_CHART,
367 + "",
368 "Number of dirty pages",
369 EBPF_CACHESTAT_DIMENSION_PAGE,
370 NETDATA_CACHESTAT_SUBMENU,
@@ -373,6 +375,7 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
375
376 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
377 NETDATA_CACHESTAT_HIT_CHART,
378 + "",
379 "Number of accessed files",
380 EBPF_CACHESTAT_DIMENSION_HITS,
381 NETDATA_CACHESTAT_SUBMENU,
@@ -383,6 +386,7 @@ static void ebpf_obsolete_services(ebpf_module_t *em)
386
387 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
388 NETDATA_CACHESTAT_MISSES_CHART,
389 + "",
390 "Files out of page cache",
391 EBPF_CACHESTAT_DIMENSION_MISSES,
392 NETDATA_CACHESTAT_SUBMENU,
@@ -425,6 +429,7 @@ static void ebpf_obsolete_cachestat_global(ebpf_module_t *em)
429 {
430 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
431 NETDATA_CACHESTAT_HIT_RATIO_CHART,
432 + "",
433 "Hit ratio",
434 EBPF_COMMON_DIMENSION_PERCENTAGE,
435 NETDATA_CACHESTAT_SUBMENU,
@@ -435,6 +440,7 @@ static void ebpf_obsolete_cachestat_global(ebpf_module_t *em)
440
441 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
442 NETDATA_CACHESTAT_DIRTY_CHART,
443 + "",
444 "Number of dirty pages",
445 EBPF_CACHESTAT_DIMENSION_PAGE,
446 NETDATA_CACHESTAT_SUBMENU,
@@ -445,6 +451,7 @@ static void ebpf_obsolete_cachestat_global(ebpf_module_t *em)
451
452 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
453 NETDATA_CACHESTAT_HIT_CHART,
454 + "",
455 "Number of accessed files",
456 EBPF_CACHESTAT_DIMENSION_HITS,
457 NETDATA_CACHESTAT_SUBMENU,
@@ -455,6 +462,7 @@ static void ebpf_obsolete_cachestat_global(ebpf_module_t *em)
462
463 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
464 NETDATA_CACHESTAT_MISSES_CHART,
465 + "",
466 "Files out of page cache",
467 EBPF_CACHESTAT_DIMENSION_MISSES,
468 NETDATA_CACHESTAT_SUBMENU,
@@ -473,44 +481,57 @@ static void ebpf_obsolete_cachestat_global(ebpf_module_t *em)
481 */
482 void ebpf_obsolete_cachestat_apps_charts(struct ebpf_module *em)
483 {
476 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
477 - NETDATA_CACHESTAT_HIT_RATIO_CHART,
478 - "Hit ratio",
479 - EBPF_COMMON_DIMENSION_PERCENTAGE,
480 - NETDATA_CACHESTAT_SUBMENU,
481 - NETDATA_EBPF_CHART_TYPE_LINE,
482 - NULL,
483 - 20090,
484 - em->update_every);
484 + struct ebpf_target *w;
485 + int update_every = em->update_every;
486 + for (w = apps_groups_root_target; w; w = w->next) {
487 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_CACHESTAT_IDX))))
488 + continue;
489
486 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
487 - NETDATA_CACHESTAT_DIRTY_CHART,
488 - "Number of dirty pages",
489 - EBPF_CACHESTAT_DIMENSION_PAGE,
490 - NETDATA_CACHESTAT_SUBMENU,
491 - NETDATA_EBPF_CHART_TYPE_STACKED,
492 - NULL,
493 - 20091,
494 - em->update_every);
490 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
491 + w->clean_name,
492 + "_ebpf_cachestat_hit_ratio",
493 + "Hit ratio",
494 + EBPF_COMMON_DIMENSION_PERCENTAGE,
495 + NETDATA_CACHESTAT_SUBMENU,
496 + NETDATA_EBPF_CHART_TYPE_LINE,
497 + "app.ebpf_cachestat_hit_ratio",
498 + 20260,
499 + update_every);
500
496 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY, NETDATA_CACHESTAT_HIT_CHART,
497 - "Number of accessed files",
498 - EBPF_CACHESTAT_DIMENSION_HITS,
499 - NETDATA_CACHESTAT_SUBMENU,
500 - NETDATA_EBPF_CHART_TYPE_STACKED,
501 - NULL,
502 - 20092,
503 - em->update_every);
501 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
502 + w->clean_name,
503 + "_ebpf_cachestat_dirty_pages",
504 + "Number of dirty pages",
505 + EBPF_CACHESTAT_DIMENSION_PAGE,
506 + NETDATA_CACHESTAT_SUBMENU,
507 + NETDATA_EBPF_CHART_TYPE_STACKED,
508 + "app.ebpf_cachestat_dirty_pages",
509 + 20261,
510 + update_every);
511
505 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
506 - NETDATA_CACHESTAT_MISSES_CHART,
507 - "Files out of page cache",
508 - EBPF_CACHESTAT_DIMENSION_MISSES,
509 - NETDATA_CACHESTAT_SUBMENU,
510 - NETDATA_EBPF_CHART_TYPE_STACKED,
511 - NULL,
512 - 20093,
513 - em->update_every);
512 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
513 + w->clean_name,
514 + "_ebpf_cachestat_access",
515 + "Number of accessed files",
516 + EBPF_CACHESTAT_DIMENSION_HITS,
517 + NETDATA_CACHESTAT_SUBMENU,
518 + NETDATA_EBPF_CHART_TYPE_STACKED,
519 + "app.ebpf_cachestat_access",
520 + 20262,
521 + update_every);
522 +
523 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
524 + w->clean_name,
525 + "_ebpf_cachestat_misses",
526 + "Files out of page cache",
527 + EBPF_CACHESTAT_DIMENSION_MISSES,
528 + NETDATA_CACHESTAT_SUBMENU,
529 + NETDATA_EBPF_CHART_TYPE_STACKED,
530 + "app.ebpf_cachestat_misses",
531 + 20263,
532 + update_every);
533 + w->charts_created &= ~(1<<EBPF_MODULE_CACHESTAT_IDX);
534 + }
535 }
536
537 /**
@@ -804,41 +825,74 @@ static void ebpf_update_cachestat_cgroup(int maps_per_core)
825 void ebpf_cachestat_create_apps_charts(struct ebpf_module *em, void *ptr)
826 {
827 struct ebpf_target *root = ptr;
807 - ebpf_create_charts_on_apps(NETDATA_CACHESTAT_HIT_RATIO_CHART,
808 - "Hit ratio",
809 - EBPF_COMMON_DIMENSION_PERCENTAGE,
810 - NETDATA_CACHESTAT_SUBMENU,
811 - NETDATA_EBPF_CHART_TYPE_LINE,
812 - 20090,
813 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
814 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);
815 -
816 - ebpf_create_charts_on_apps(NETDATA_CACHESTAT_DIRTY_CHART,
817 - "Number of dirty pages",
818 - EBPF_CACHESTAT_DIMENSION_PAGE,
819 - NETDATA_CACHESTAT_SUBMENU,
820 - NETDATA_EBPF_CHART_TYPE_STACKED,
821 - 20091,
822 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
823 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);
824 -
825 - ebpf_create_charts_on_apps(NETDATA_CACHESTAT_HIT_CHART,
826 - "Number of accessed files",
827 - EBPF_CACHESTAT_DIMENSION_HITS,
828 - NETDATA_CACHESTAT_SUBMENU,
829 - NETDATA_EBPF_CHART_TYPE_STACKED,
830 - 20092,
831 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
832 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);
833 -
834 - ebpf_create_charts_on_apps(NETDATA_CACHESTAT_MISSES_CHART,
835 - "Files out of page cache",
836 - EBPF_CACHESTAT_DIMENSION_MISSES,
837 - NETDATA_CACHESTAT_SUBMENU,
838 - NETDATA_EBPF_CHART_TYPE_STACKED,
839 - 20093,
840 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
841 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_CACHESTAT);
828 + struct ebpf_target *w;
829 + int update_every = em->update_every;
830 + for (w = root; w; w = w->next) {
831 + if (unlikely(!w->exposed))
832 + continue;
833 +
834 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
835 + w->clean_name,
836 + "_ebpf_cachestat_hit_ratio",
837 + "Hit ratio",
838 + EBPF_COMMON_DIMENSION_PERCENTAGE,
839 + NETDATA_CACHESTAT_SUBMENU,
840 + NETDATA_EBPF_CHART_TYPE_LINE,
841 + "app.ebpf_cachestat_hit_ratio",
842 + 20260,
843 + update_every,
844 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);
845 + ebpf_create_chart_labels("app_group", w->name, 0);
846 + ebpf_commit_label();
847 + fprintf(stdout, "DIMENSION ratio '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
848 +
849 +
850 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
851 + w->clean_name,
852 + "_ebpf_cachestat_dirty_pages",
853 + "Number of dirty pages",
854 + EBPF_CACHESTAT_DIMENSION_PAGE,
855 + NETDATA_CACHESTAT_SUBMENU,
856 + NETDATA_EBPF_CHART_TYPE_LINE,
857 + "app.ebpf_cachestat_dirty_pages",
858 + 20261,
859 + update_every,
860 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);
861 + ebpf_create_chart_labels("app_group", w->name, 0);
862 + ebpf_commit_label();
863 + fprintf(stdout, "DIMENSION pages '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
864 +
865 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
866 + w->clean_name,
867 + "_ebpf_cachestat_access",
868 + "Number of accessed files",
869 + EBPF_CACHESTAT_DIMENSION_HITS,
870 + NETDATA_CACHESTAT_SUBMENU,
871 + NETDATA_EBPF_CHART_TYPE_STACKED,
872 + "app.ebpf_cachestat_access",
873 + 20262,
874 + update_every,
875 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);
876 + ebpf_create_chart_labels("app_group", w->name, 0);
877 + ebpf_commit_label();
878 + fprintf(stdout, "DIMENSION hits '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
879 +
880 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
881 + w->clean_name,
882 + "_ebpf_cachestat_misses",
883 + "Files out of page cache",
884 + EBPF_CACHESTAT_DIMENSION_MISSES,
885 + NETDATA_CACHESTAT_SUBMENU,
886 + NETDATA_EBPF_CHART_TYPE_STACKED,
887 + "app.ebpf_cachestat_misses",
888 + 20263,
889 + update_every,
890 + NETDATA_EBPF_MODULE_NAME_CACHESTAT);
891 + ebpf_create_chart_labels("app_group", w->name, 0);
892 + ebpf_commit_label();
893 + fprintf(stdout, "DIMENSION misses '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
894 + w->charts_created |= 1<<EBPF_MODULE_CACHESTAT_IDX;
895 + }
896
897 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
898 }
@@ -939,53 +993,42 @@ void ebpf_cache_send_apps_data(struct ebpf_target *root)
993 struct ebpf_target *w;
994 collected_number value;
995
942 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_CACHESTAT_HIT_RATIO_CHART);
996 for (w = root; w; w = w->next) {
944 - if (unlikely(w->exposed && w->processes)) {
945 - ebpf_cachestat_sum_pids(&w->cachestat, w->root_pid);
946 - netdata_cachestat_pid_t *current = &w->cachestat.current;
947 - netdata_cachestat_pid_t *prev = &w->cachestat.prev;
948 -
949 - uint64_t mpa = current->mark_page_accessed - prev->mark_page_accessed;
950 - uint64_t mbd = current->mark_buffer_dirty - prev->mark_buffer_dirty;
951 - w->cachestat.dirty = mbd;
952 - uint64_t apcl = current->add_to_page_cache_lru - prev->add_to_page_cache_lru;
953 - uint64_t apd = current->account_page_dirtied - prev->account_page_dirtied;
954 -
955 - cachestat_update_publish(&w->cachestat, mpa, mbd, apcl, apd);
956 - value = (collected_number) w->cachestat.ratio;
957 - // Here we are using different approach to have a chart more smooth
958 - write_chart_dimension(w->name, value);
959 - }
960 - }
961 - write_end_chart();
997 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_CACHESTAT_IDX))))
998 + continue;
999
963 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_CACHESTAT_DIRTY_CHART);
964 - for (w = root; w; w = w->next) {
965 - if (unlikely(w->exposed && w->processes)) {
966 - value = (collected_number) w->cachestat.dirty;
967 - write_chart_dimension(w->name, value);
968 - }
969 - }
970 - write_end_chart();
1000 + ebpf_cachestat_sum_pids(&w->cachestat, w->root_pid);
1001 + netdata_cachestat_pid_t *current = &w->cachestat.current;
1002 + netdata_cachestat_pid_t *prev = &w->cachestat.prev;
1003
972 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_CACHESTAT_HIT_CHART);
973 - for (w = root; w; w = w->next) {
974 - if (unlikely(w->exposed && w->processes)) {
975 - value = (collected_number) w->cachestat.hit;
976 - write_chart_dimension(w->name, value);
977 - }
978 - }
979 - write_end_chart();
1004 + uint64_t mpa = current->mark_page_accessed - prev->mark_page_accessed;
1005 + uint64_t mbd = current->mark_buffer_dirty - prev->mark_buffer_dirty;
1006 + w->cachestat.dirty = mbd;
1007 + uint64_t apcl = current->add_to_page_cache_lru - prev->add_to_page_cache_lru;
1008 + uint64_t apd = current->account_page_dirtied - prev->account_page_dirtied;
1009
981 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_CACHESTAT_MISSES_CHART);
982 - for (w = root; w; w = w->next) {
983 - if (unlikely(w->exposed && w->processes)) {
984 - value = (collected_number) w->cachestat.miss;
985 - write_chart_dimension(w->name, value);
986 - }
1010 + cachestat_update_publish(&w->cachestat, mpa, mbd, apcl, apd);
1011 +
1012 + value = (collected_number) w->cachestat.ratio;
1013 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_hit_ratio");
1014 + write_chart_dimension("ratio", value);
1015 + ebpf_write_end_chart();
1016 +
1017 + value = (collected_number) w->cachestat.dirty;
1018 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_dirty_pages");
1019 + write_chart_dimension("pages", value);
1020 + ebpf_write_end_chart();
1021 +
1022 + value = (collected_number) w->cachestat.hit;
1023 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_access");
1024 + write_chart_dimension("hits", value);
1025 + ebpf_write_end_chart();
1026 +
1027 + value = (collected_number) w->cachestat.miss;
1028 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_cachestat_misses");
1029 + write_chart_dimension("misses", value);
1030 + ebpf_write_end_chart();
1031 }
988 - write_end_chart();
1032 }
1033
1034 /**
@@ -1087,37 +1130,37 @@ static void ebpf_send_systemd_cachestat_charts()
1130 {
1131 ebpf_cgroup_target_t *ect;
1132
1090 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_HIT_RATIO_CHART);
1133 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_HIT_RATIO_CHART, "");
1134 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1135 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1136 write_chart_dimension(ect->name, (long long)ect->publish_cachestat.ratio);
1137 }
1138 }
1096 - write_end_chart();
1139 + ebpf_write_end_chart();
1140
1098 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_DIRTY_CHART);
1141 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_DIRTY_CHART, "");
1142 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1143 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1144 write_chart_dimension(ect->name, (long long)ect->publish_cachestat.dirty);
1145 }
1146 }
1104 - write_end_chart();
1147 + ebpf_write_end_chart();
1148
1106 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_HIT_CHART);
1149 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_HIT_CHART, "");
1150 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1151 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1152 write_chart_dimension(ect->name, (long long)ect->publish_cachestat.hit);
1153 }
1154 }
1112 - write_end_chart();
1155 + ebpf_write_end_chart();
1156
1114 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_MISSES_CHART);
1157 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_CACHESTAT_MISSES_CHART, "");
1158 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
1159 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1160 write_chart_dimension(ect->name, (long long)ect->publish_cachestat.miss);
1161 }
1162 }
1120 - write_end_chart();
1163 + ebpf_write_end_chart();
1164 }
1165
1166 /**
@@ -1127,21 +1170,21 @@ static void ebpf_send_systemd_cachestat_charts()
1170 */
1171 static void ebpf_send_specific_cachestat_data(char *type, netdata_publish_cachestat_t *npc)
1172 {
1130 - write_begin_chart(type, NETDATA_CACHESTAT_HIT_RATIO_CHART);
1173 + ebpf_write_begin_chart(type, NETDATA_CACHESTAT_HIT_RATIO_CHART, "");
1174 write_chart_dimension(cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_RATIO].name, (long long)npc->ratio);
1132 - write_end_chart();
1175 + ebpf_write_end_chart();
1176
1134 - write_begin_chart(type, NETDATA_CACHESTAT_DIRTY_CHART);
1177 + ebpf_write_begin_chart(type, NETDATA_CACHESTAT_DIRTY_CHART, "");
1178 write_chart_dimension(cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_DIRTY].name, (long long)npc->dirty);
1136 - write_end_chart();
1179 + ebpf_write_end_chart();
1180
1138 - write_begin_chart(type, NETDATA_CACHESTAT_HIT_CHART);
1181 + ebpf_write_begin_chart(type, NETDATA_CACHESTAT_HIT_CHART, "");
1182 write_chart_dimension(cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_HIT].name, (long long)npc->hit);
1140 - write_end_chart();
1183 + ebpf_write_end_chart();
1184
1142 - write_begin_chart(type, NETDATA_CACHESTAT_MISSES_CHART);
1185 + ebpf_write_begin_chart(type, NETDATA_CACHESTAT_MISSES_CHART, "");
1186 write_chart_dimension(cachestat_counter_publish_aggregated[NETDATA_CACHESTAT_IDX_MISS].name, (long long)npc->miss);
1144 - write_end_chart();
1187 + ebpf_write_end_chart();
1188 }
1189
1190 /**
@@ -1201,24 +1244,28 @@ static void ebpf_create_specific_cachestat_charts(char *type, int update_every)
1244 static void ebpf_obsolete_specific_cachestat_charts(char *type, int update_every)
1245 {
1246 ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_HIT_RATIO_CHART,
1247 + "",
1248 "Hit ratio",
1249 EBPF_COMMON_DIMENSION_PERCENTAGE, NETDATA_CACHESTAT_SUBMENU,
1250 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_HIT_RATIO_CONTEXT,
1251 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5200, update_every);
1252
1253 ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_DIRTY_CHART,
1254 + "",
1255 "Number of dirty pages",
1256 EBPF_CACHESTAT_DIMENSION_PAGE, NETDATA_CACHESTAT_SUBMENU,
1257 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_MODIFIED_CACHE_CONTEXT,
1258 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5201, update_every);
1259
1260 ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_HIT_CHART,
1261 + "",
1262 "Number of accessed files",
1263 EBPF_CACHESTAT_DIMENSION_HITS, NETDATA_CACHESTAT_SUBMENU,
1264 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_HIT_FILES_CONTEXT,
1265 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5202, update_every);
1266
1267 ebpf_write_chart_obsolete(type, NETDATA_CACHESTAT_MISSES_CHART,
1268 + "",
1269 "Files out of page cache",
1270 EBPF_CACHESTAT_DIMENSION_MISSES, NETDATA_CACHESTAT_SUBMENU,
1271 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_CACHESTAT_MISS_FILES_CONTEXT,
collectors/ebpf.plugin/ebpf_cgroup.c
+1 -1
@@ -331,7 +331,7 @@ void ebpf_create_charts_on_systemd(char *id, char *title, char *units, char *fam
331 char *algorithm, char *context, char *module, int update_every)
332 {
333 ebpf_cgroup_target_t *w;
334 - ebpf_write_chart_cmd(NETDATA_SERVICE_FAMILY, id, title, units, family, charttype, context,
334 + ebpf_write_chart_cmd(NETDATA_SERVICE_FAMILY, id, "", title, units, family, charttype, context,
335 order, update_every, module);
336
337 for (w = ebpf_cgroup_pids; w; w = w->next) {
collectors/ebpf.plugin/ebpf_dcstat.c
+179 -134
@@ -302,6 +302,7 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
302 {
303 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
304 NETDATA_DC_HIT_CHART,
305 + "",
306 "Percentage of files inside directory cache",
307 EBPF_COMMON_DIMENSION_PERCENTAGE,
308 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -312,6 +313,7 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
313
314 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
315 NETDATA_DC_REFERENCE_CHART,
316 + "",
317 "Count file access",
318 EBPF_COMMON_DIMENSION_FILES,
319 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -322,6 +324,7 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
324
325 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
326 NETDATA_DC_REQUEST_NOT_CACHE_CHART,
327 + "",
328 "Files not present inside directory cache",
329 EBPF_COMMON_DIMENSION_FILES,
330 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -332,6 +335,7 @@ static void ebpf_obsolete_dc_services(ebpf_module_t *em)
335
336 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
337 NETDATA_DC_REQUEST_NOT_FOUND_CHART,
338 + "",
339 "Files not found",
340 EBPF_COMMON_DIMENSION_FILES,
341 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -372,45 +376,58 @@ static inline void ebpf_obsolete_dc_cgroup_charts(ebpf_module_t *em) {
376 */
377 void ebpf_obsolete_dc_apps_charts(struct ebpf_module *em)
378 {
375 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
376 - NETDATA_DC_HIT_CHART,
377 - "Percentage of files inside directory cache",
378 - EBPF_COMMON_DIMENSION_PERCENTAGE,
379 - NETDATA_DIRECTORY_CACHE_SUBMENU,
380 - NETDATA_EBPF_CHART_TYPE_LINE,
381 - NULL,
382 - 20100,
383 - em->update_every);
379 + struct ebpf_target *w;
380 + int update_every = em->update_every;
381 + for (w = apps_groups_root_target; w; w = w->next) {
382 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_DCSTAT_IDX))))
383 + continue;
384
385 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
386 - NETDATA_DC_REFERENCE_CHART,
387 - "Count file access",
388 - EBPF_COMMON_DIMENSION_FILES,
389 - NETDATA_DIRECTORY_CACHE_SUBMENU,
390 - NETDATA_EBPF_CHART_TYPE_STACKED,
391 - NULL,
392 - 20101,
393 - em->update_every);
385 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
386 + w->clean_name,
387 + "_ebpf_dc_hit",
388 + "Percentage of files inside directory cache.",
389 + EBPF_COMMON_DIMENSION_PERCENTAGE,
390 + NETDATA_DIRECTORY_CACHE_SUBMENU,
391 + NETDATA_EBPF_CHART_TYPE_LINE,
392 + "app.ebpf_dc_hit",
393 + 20265,
394 + update_every);
395
395 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
396 - NETDATA_DC_REQUEST_NOT_CACHE_CHART,
397 - "Files not present inside directory cache",
398 - EBPF_COMMON_DIMENSION_FILES,
399 - NETDATA_DIRECTORY_CACHE_SUBMENU,
400 - NETDATA_EBPF_CHART_TYPE_STACKED,
401 - NULL,
402 - 20102,
403 - em->update_every);
396 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
397 + w->clean_name,
398 + "_ebpf_dc_reference",
399 + "Count file access.",
400 + EBPF_COMMON_DIMENSION_FILES,
401 + NETDATA_DIRECTORY_CACHE_SUBMENU,
402 + NETDATA_EBPF_CHART_TYPE_STACKED,
403 + "app.ebpf_dc_reference",
404 + 20266,
405 + update_every);
406
405 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
406 - NETDATA_DC_REQUEST_NOT_FOUND_CHART,
407 - "Files not found",
408 - EBPF_COMMON_DIMENSION_FILES,
409 - NETDATA_DIRECTORY_CACHE_SUBMENU,
410 - NETDATA_EBPF_CHART_TYPE_STACKED,
411 - NULL,
412 - 20103,
413 - em->update_every);
407 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
408 + w->clean_name,
409 + "_ebpf_not_cache",
410 + "Files not present inside directory cache.",
411 + EBPF_COMMON_DIMENSION_FILES,
412 + NETDATA_DIRECTORY_CACHE_SUBMENU,
413 + NETDATA_EBPF_CHART_TYPE_STACKED,
414 + "app.ebpf_dc_not_cache",
415 + 20267,
416 + update_every);
417 +
418 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
419 + w->clean_name,
420 + "_ebpf_not_found",
421 + "Files not found.",
422 + EBPF_COMMON_DIMENSION_FILES,
423 + NETDATA_DIRECTORY_CACHE_SUBMENU,
424 + NETDATA_EBPF_CHART_TYPE_STACKED,
425 + "app.ebpf_dc_not_found",
426 + 20268,
427 + update_every);
428 +
429 + w->charts_created &= ~(1<<EBPF_MODULE_DCSTAT_IDX);
430 + }
431 }
432
433 /**
@@ -424,6 +441,7 @@ static void ebpf_obsolete_dc_global(ebpf_module_t *em)
441 {
442 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
443 NETDATA_DC_HIT_CHART,
444 + "",
445 "Percentage of files inside directory cache",
446 EBPF_COMMON_DIMENSION_PERCENTAGE,
447 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -434,6 +452,7 @@ static void ebpf_obsolete_dc_global(ebpf_module_t *em)
452
453 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
454 NETDATA_DC_REFERENCE_CHART,
455 + "",
456 "Variables used to calculate hit ratio.",
457 EBPF_COMMON_DIMENSION_FILES,
458 NETDATA_DIRECTORY_CACHE_SUBMENU,
@@ -513,41 +532,74 @@ static void ebpf_dcstat_exit(void *ptr)
532 void ebpf_dcstat_create_apps_charts(struct ebpf_module *em, void *ptr)
533 {
534 struct ebpf_target *root = ptr;
516 - ebpf_create_charts_on_apps(NETDATA_DC_HIT_CHART,
517 - "Percentage of files inside directory cache",
518 - EBPF_COMMON_DIMENSION_PERCENTAGE,
519 - NETDATA_DIRECTORY_CACHE_SUBMENU,
520 - NETDATA_EBPF_CHART_TYPE_LINE,
521 - 20100,
522 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
523 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);
524 -
525 - ebpf_create_charts_on_apps(NETDATA_DC_REFERENCE_CHART,
526 - "Count file access",
527 - EBPF_COMMON_DIMENSION_FILES,
528 - NETDATA_DIRECTORY_CACHE_SUBMENU,
529 - NETDATA_EBPF_CHART_TYPE_STACKED,
530 - 20101,
531 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
532 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);
533 -
534 - ebpf_create_charts_on_apps(NETDATA_DC_REQUEST_NOT_CACHE_CHART,
535 - "Files not present inside directory cache",
536 - EBPF_COMMON_DIMENSION_FILES,
537 - NETDATA_DIRECTORY_CACHE_SUBMENU,
538 - NETDATA_EBPF_CHART_TYPE_STACKED,
539 - 20102,
540 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
541 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);
542 -
543 - ebpf_create_charts_on_apps(NETDATA_DC_REQUEST_NOT_FOUND_CHART,
544 - "Files not found",
545 - EBPF_COMMON_DIMENSION_FILES,
546 - NETDATA_DIRECTORY_CACHE_SUBMENU,
547 - NETDATA_EBPF_CHART_TYPE_STACKED,
548 - 20103,
549 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
550 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_DCSTAT);
535 + struct ebpf_target *w;
536 + int update_every = em->update_every;
537 + for (w = root; w; w = w->next) {
538 + if (unlikely(!w->exposed))
539 + continue;
540 +
541 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
542 + w->clean_name,
543 + "_ebpf_dc_hit",
544 + "Percentage of files inside directory cache.",
545 + EBPF_COMMON_DIMENSION_PERCENTAGE,
546 + NETDATA_DIRECTORY_CACHE_SUBMENU,
547 + NETDATA_EBPF_CHART_TYPE_LINE,
548 + "app.ebpf_dc_hit",
549 + 20265,
550 + update_every,
551 + NETDATA_EBPF_MODULE_NAME_DCSTAT);
552 + ebpf_create_chart_labels("app_group", w->name, 0);
553 + ebpf_commit_label();
554 + fprintf(stdout, "DIMENSION ratio '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
555 +
556 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
557 + w->clean_name,
558 + "_ebpf_dc_reference",
559 + "Count file access.",
560 + EBPF_COMMON_DIMENSION_FILES,
561 + NETDATA_DIRECTORY_CACHE_SUBMENU,
562 + NETDATA_EBPF_CHART_TYPE_STACKED,
563 + "app.ebpf_dc_reference",
564 + 20266,
565 + update_every,
566 + NETDATA_EBPF_MODULE_NAME_DCSTAT);
567 + ebpf_create_chart_labels("app_group", w->name, 0);
568 + ebpf_commit_label();
569 + fprintf(stdout, "DIMENSION files '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
570 +
571 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
572 + w->clean_name,
573 + "_ebpf_not_cache",
574 + "Files not present inside directory cache.",
575 + EBPF_COMMON_DIMENSION_FILES,
576 + NETDATA_DIRECTORY_CACHE_SUBMENU,
577 + NETDATA_EBPF_CHART_TYPE_STACKED,
578 + "app.ebpf_dc_not_cache",
579 + 20267,
580 + update_every,
581 + NETDATA_EBPF_MODULE_NAME_DCSTAT);
582 + ebpf_create_chart_labels("app_group", w->name, 0);
583 + ebpf_commit_label();
584 + fprintf(stdout, "DIMENSION files '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
585 +
586 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
587 + w->clean_name,
588 + "_ebpf_not_found",
589 + "Files not found.",
590 + EBPF_COMMON_DIMENSION_FILES,
591 + NETDATA_DIRECTORY_CACHE_SUBMENU,
592 + NETDATA_EBPF_CHART_TYPE_STACKED,
593 + "app.ebpf_dc_not_found",
594 + 20268,
595 + update_every,
596 + NETDATA_EBPF_MODULE_NAME_DCSTAT);
597 + ebpf_create_chart_labels("app_group", w->name, 0);
598 + ebpf_commit_label();
599 + fprintf(stdout, "DIMENSION files '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
600 +
601 + w->charts_created |= 1<<EBPF_MODULE_DCSTAT_IDX;
602 + }
603
604 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
605 }
@@ -746,64 +798,53 @@ void ebpf_dcache_send_apps_data(struct ebpf_target *root)
798 struct ebpf_target *w;
799 collected_number value;
800
749 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_HIT_CHART);
801 for (w = root; w; w = w->next) {
751 - if (unlikely(w->exposed && w->processes)) {
752 - ebpf_dcstat_sum_pids(&w->dcstat, w->root_pid);
802 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_DCSTAT_IDX))))
803 + continue;
804
754 - uint64_t cache = w->dcstat.curr.cache_access;
755 - uint64_t not_found = w->dcstat.curr.not_found;
805 + ebpf_dcstat_sum_pids(&w->dcstat, w->root_pid);
806
757 - dcstat_update_publish(&w->dcstat, cache, not_found);
758 - value = (collected_number) w->dcstat.ratio;
759 - write_chart_dimension(w->name, value);
760 - }
761 - }
762 - write_end_chart();
807 + uint64_t cache = w->dcstat.curr.cache_access;
808 + uint64_t not_found = w->dcstat.curr.not_found;
809
764 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_REFERENCE_CHART);
765 - for (w = root; w; w = w->next) {
766 - if (unlikely(w->exposed && w->processes)) {
767 - if (w->dcstat.curr.cache_access < w->dcstat.prev.cache_access) {
768 - w->dcstat.prev.cache_access = 0;
769 - }
810 + dcstat_update_publish(&w->dcstat, cache, not_found);
811 +
812 + value = (collected_number) w->dcstat.ratio;
813 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_dc_hit");
814 + write_chart_dimension("ratio", value);
815 + ebpf_write_end_chart();
816
771 - w->dcstat.cache_access = (long long)w->dcstat.curr.cache_access - (long long)w->dcstat.prev.cache_access;
772 - value = (collected_number) w->dcstat.cache_access;
773 - write_chart_dimension(w->name, value);
774 - w->dcstat.prev.cache_access = w->dcstat.curr.cache_access;
817 + if (w->dcstat.curr.cache_access < w->dcstat.prev.cache_access) {
818 + w->dcstat.prev.cache_access = 0;
819 }
776 - }
777 - write_end_chart();
820 + w->dcstat.cache_access = (long long)w->dcstat.curr.cache_access - (long long)w->dcstat.prev.cache_access;
821
779 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_REQUEST_NOT_CACHE_CHART);
780 - for (w = root; w; w = w->next) {
781 - if (unlikely(w->exposed && w->processes)) {
782 - if (w->dcstat.curr.file_system < w->dcstat.prev.file_system) {
783 - w->dcstat.prev.file_system = 0;
784 - }
822 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_dc_reference");
823 + value = (collected_number) w->dcstat.cache_access;
824 + write_chart_dimension("files", value);
825 + ebpf_write_end_chart();
826 + w->dcstat.prev.cache_access = w->dcstat.curr.cache_access;
827
786 - value = (collected_number) (!w->dcstat.cache_access) ? 0 :
787 - (long long )w->dcstat.curr.file_system - (long long)w->dcstat.prev.file_system;
788 - write_chart_dimension(w->name, value);
789 - w->dcstat.prev.file_system = w->dcstat.curr.file_system;
828 + if (w->dcstat.curr.file_system < w->dcstat.prev.file_system) {
829 + w->dcstat.prev.file_system = 0;
830 }
791 - }
792 - write_end_chart();
793 -
794 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_DC_REQUEST_NOT_FOUND_CHART);
795 - for (w = root; w; w = w->next) {
796 - if (unlikely(w->exposed && w->processes)) {
797 - if (w->dcstat.curr.not_found < w->dcstat.prev.not_found) {
798 - w->dcstat.prev.not_found = 0;
799 - }
800 - value = (collected_number) (!w->dcstat.cache_access) ? 0 :
801 - (long long)w->dcstat.curr.not_found - (long long)w->dcstat.prev.not_found;
802 - write_chart_dimension(w->name, value);
803 - w->dcstat.prev.not_found = w->dcstat.curr.not_found;
831 + value = (collected_number) (!w->dcstat.cache_access) ? 0 :
832 + (long long )w->dcstat.curr.file_system - (long long)w->dcstat.prev.file_system;
833 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_not_cache");
834 + write_chart_dimension("files", value);
835 + ebpf_write_end_chart();
836 + w->dcstat.prev.file_system = w->dcstat.curr.file_system;
837 +
838 + if (w->dcstat.curr.not_found < w->dcstat.prev.not_found) {
839 + w->dcstat.prev.not_found = 0;
840 }
841 + value = (collected_number) (!w->dcstat.cache_access) ? 0 :
842 + (long long)w->dcstat.curr.not_found - (long long)w->dcstat.prev.not_found;
843 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_not_found");
844 + write_chart_dimension("files", value);
845 + ebpf_write_end_chart();
846 + w->dcstat.prev.not_found = w->dcstat.curr.not_found;
847 }
806 - write_end_chart();
848 }
849
850 /**
@@ -898,24 +939,28 @@ static void ebpf_create_specific_dc_charts(char *type, int update_every)
939 static void ebpf_obsolete_specific_dc_charts(char *type, int update_every)
940 {
941 ebpf_write_chart_obsolete(type, NETDATA_DC_HIT_CHART,
942 + "",
943 "Percentage of files inside directory cache",
944 EBPF_COMMON_DIMENSION_PERCENTAGE, NETDATA_DIRECTORY_CACHE_SUBMENU,
945 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_HIT_RATIO_CONTEXT,
946 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5700, update_every);
947
948 ebpf_write_chart_obsolete(type, NETDATA_DC_REFERENCE_CHART,
949 + "",
950 "Count file access",
951 EBPF_COMMON_DIMENSION_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,
952 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_REFERENCE_CONTEXT,
953 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5701, update_every);
954
955 ebpf_write_chart_obsolete(type, NETDATA_DC_REQUEST_NOT_CACHE_CHART,
956 + "",
957 "Files not present inside directory cache",
958 EBPF_COMMON_DIMENSION_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,
959 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_NOT_CACHE_CONTEXT,
960 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5702, update_every);
961
962 ebpf_write_chart_obsolete(type, NETDATA_DC_REQUEST_NOT_FOUND_CHART,
963 + "",
964 "Files not found",
965 EBPF_COMMON_DIMENSION_FILES, NETDATA_DIRECTORY_CACHE_SUBMENU,
966 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_DC_NOT_FOUND_CONTEXT,
@@ -1029,23 +1074,23 @@ static void ebpf_send_systemd_dc_charts()
1074 {
1075 collected_number value;
1076 ebpf_cgroup_target_t *ect;
1032 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_HIT_CHART);
1077 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_HIT_CHART, "");
1078 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1079 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1080 write_chart_dimension(ect->name, (long long) ect->publish_dc.ratio);
1081 }
1082 }
1038 - write_end_chart();
1083 + ebpf_write_end_chart();
1084
1040 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REFERENCE_CHART);
1085 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REFERENCE_CHART, "");
1086 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1087 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1088 write_chart_dimension(ect->name, (long long) ect->publish_dc.cache_access);
1089 }
1090 }
1046 - write_end_chart();
1091 + ebpf_write_end_chart();
1092
1048 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REQUEST_NOT_CACHE_CHART);
1093 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REQUEST_NOT_CACHE_CHART, "");
1094 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1095 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1096 value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :
@@ -1055,9 +1100,9 @@ static void ebpf_send_systemd_dc_charts()
1100 write_chart_dimension(ect->name, (long long) value);
1101 }
1102 }
1058 - write_end_chart();
1103 + ebpf_write_end_chart();
1104
1060 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REQUEST_NOT_FOUND_CHART);
1105 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_DC_REQUEST_NOT_FOUND_CHART, "");
1106 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1107 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1108 value = (collected_number) (!ect->publish_dc.cache_access) ? 0 :
@@ -1068,7 +1113,7 @@ static void ebpf_send_systemd_dc_charts()
1113 write_chart_dimension(ect->name, (long long) value);
1114 }
1115 }
1071 - write_end_chart();
1116 + ebpf_write_end_chart();
1117 }
1118
1119 /**
@@ -1080,31 +1125,31 @@ static void ebpf_send_systemd_dc_charts()
1125 static void ebpf_send_specific_dc_data(char *type, netdata_publish_dcstat_t *pdc)
1126 {
1127 collected_number value;
1083 - write_begin_chart(type, NETDATA_DC_HIT_CHART);
1128 + ebpf_write_begin_chart(type, NETDATA_DC_HIT_CHART, "");
1129 write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_RATIO].name,
1130 (long long) pdc->ratio);
1086 - write_end_chart();
1131 + ebpf_write_end_chart();
1132
1088 - write_begin_chart(type, NETDATA_DC_REFERENCE_CHART);
1133 + ebpf_write_begin_chart(type, NETDATA_DC_REFERENCE_CHART, "");
1134 write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_REFERENCE].name,
1135 (long long) pdc->cache_access);
1091 - write_end_chart();
1136 + ebpf_write_end_chart();
1137
1138 value = (collected_number) (!pdc->cache_access) ? 0 :
1139 (long long )pdc->curr.file_system - (long long)pdc->prev.file_system;
1140 pdc->prev.file_system = pdc->curr.file_system;
1141
1097 - write_begin_chart(type, NETDATA_DC_REQUEST_NOT_CACHE_CHART);
1142 + ebpf_write_begin_chart(type, NETDATA_DC_REQUEST_NOT_CACHE_CHART, "");
1143 write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_SLOW].name, (long long) value);
1099 - write_end_chart();
1144 + ebpf_write_end_chart();
1145
1146 value = (collected_number) (!pdc->cache_access) ? 0 :
1147 (long long)pdc->curr.not_found - (long long)pdc->prev.not_found;
1148 pdc->prev.not_found = pdc->curr.not_found;
1149
1105 - write_begin_chart(type, NETDATA_DC_REQUEST_NOT_FOUND_CHART);
1150 + ebpf_write_begin_chart(type, NETDATA_DC_REQUEST_NOT_FOUND_CHART, "");
1151 write_chart_dimension(dcstat_counter_publish_aggregated[NETDATA_DCSTAT_IDX_MISS].name, (long long) value);
1107 - write_end_chart();
1152 + ebpf_write_end_chart();
1153 }
1154
1155 /**
collectors/ebpf.plugin/ebpf_dcstat.h
+1 -1
@@ -13,7 +13,7 @@
13 #define NETDATA_DC_REQUEST_NOT_CACHE_CHART "dc_not_cache"
14 #define NETDATA_DC_REQUEST_NOT_FOUND_CHART "dc_not_found"
15
16 -#define NETDATA_DIRECTORY_CACHE_SUBMENU "directory cache (eBPF)"
16 +#define NETDATA_DIRECTORY_CACHE_SUBMENU "directory cache"
17
18 // configuration file
19 #define NETDATA_DIRECTORY_DCSTAT_CONFIG_FILE "dcstat.conf"
collectors/ebpf.plugin/ebpf_disk.c
+2 -1
@@ -485,6 +485,7 @@ static void ebpf_obsolete_disk_global(ebpf_module_t *em)
485 if (flags & NETDATA_DISK_CHART_CREATED) {
486 ebpf_write_chart_obsolete(ned->histogram.name,
487 ned->family,
488 + "",
489 "Disk latency",
490 EBPF_COMMON_DIMENSION_CALL,
491 ned->family,
@@ -655,7 +656,7 @@ static void read_hard_disk_tables(int table, int maps_per_core)
656 */
657 static void ebpf_obsolete_hd_charts(netdata_ebpf_disks_t *w, int update_every)
658 {
658 - ebpf_write_chart_obsolete(w->histogram.name, w->family, w->histogram.title, EBPF_COMMON_DIMENSION_CALL,
659 + ebpf_write_chart_obsolete(w->histogram.name, w->family, "", w->histogram.title, EBPF_COMMON_DIMENSION_CALL,
660 w->family, NETDATA_EBPF_CHART_TYPE_STACKED, "disk.latency_io",
661 w->histogram.order, update_every);
662
collectors/ebpf.plugin/ebpf_fd.c
+163 -127
@@ -386,45 +386,49 @@ static void ebpf_obsolete_fd_services(ebpf_module_t *em)
386 {
387 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
388 NETDATA_SYSCALL_APPS_FILE_OPEN,
389 + "",
390 "Number of open files",
391 EBPF_COMMON_DIMENSION_CALL,
392 NETDATA_APPS_FILE_CGROUP_GROUP,
393 NETDATA_EBPF_CHART_TYPE_STACKED,
394 NETDATA_CGROUP_FD_OPEN_CONTEXT,
394 - 20061,
395 + 20270,
396 em->update_every);
397
398 if (em->mode < MODE_ENTRY) {
399 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
400 NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,
401 + "",
402 "Fails to open files",
403 EBPF_COMMON_DIMENSION_CALL,
404 NETDATA_APPS_FILE_CGROUP_GROUP,
405 NETDATA_EBPF_CHART_TYPE_STACKED,
406 NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,
405 - 20062,
407 + 20271,
408 em->update_every);
409 }
410
411 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
412 NETDATA_SYSCALL_APPS_FILE_CLOSED,
413 + "",
414 "Files closed",
415 EBPF_COMMON_DIMENSION_CALL,
416 NETDATA_APPS_FILE_CGROUP_GROUP,
417 NETDATA_EBPF_CHART_TYPE_STACKED,
418 NETDATA_CGROUP_FD_CLOSE_CONTEXT,
416 - 20063,
419 + 20272,
420 em->update_every);
421
422 if (em->mode < MODE_ENTRY) {
423 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
424 NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,
425 + "",
426 "Fails to close files",
427 EBPF_COMMON_DIMENSION_CALL,
428 NETDATA_APPS_FILE_CGROUP_GROUP,
429 NETDATA_EBPF_CHART_TYPE_STACKED,
430 NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,
427 - 20064,
431 + 20273,
432 em->update_every);
433 }
434 }
@@ -460,48 +464,60 @@ static inline void ebpf_obsolete_fd_cgroup_charts(ebpf_module_t *em) {
464 */
465 void ebpf_obsolete_fd_apps_charts(struct ebpf_module *em)
466 {
463 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
464 - NETDATA_SYSCALL_APPS_FILE_OPEN,
465 - "Number of open files",
466 - EBPF_COMMON_DIMENSION_CALL,
467 - NETDATA_APPS_FILE_GROUP,
468 - NETDATA_EBPF_CHART_TYPE_STACKED,
469 - NULL,
470 - 20061,
471 - em->update_every);
467 + struct ebpf_target *w;
468 + int update_every = em->update_every;
469 + for (w = apps_groups_root_target; w; w = w->next) {
470 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX))))
471 + continue;
472
473 - if (em->mode < MODE_ENTRY) {
474 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
475 - NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,
476 - "Fails to open files",
473 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
474 + w->clean_name,
475 + "_ebpf_file_open",
476 + "Number of open files",
477 EBPF_COMMON_DIMENSION_CALL,
478 - NETDATA_APPS_FILE_GROUP,
478 + NETDATA_APPS_FILE_FDS,
479 NETDATA_EBPF_CHART_TYPE_STACKED,
480 - NULL,
481 - 20062,
482 - em->update_every);
483 - }
484 -
485 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
486 - NETDATA_SYSCALL_APPS_FILE_CLOSED,
487 - "Files closed",
488 - EBPF_COMMON_DIMENSION_CALL,
489 - NETDATA_APPS_FILE_GROUP,
490 - NETDATA_EBPF_CHART_TYPE_STACKED,
491 - NULL,
492 - 20063,
493 - em->update_every);
480 + "app.ebpf_file_open",
481 + 20220,
482 + update_every);
483 +
484 + if (em->mode < MODE_ENTRY) {
485 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
486 + w->clean_name,
487 + "_ebpf_file_open_error",
488 + "Fails to open files.",
489 + EBPF_COMMON_DIMENSION_CALL,
490 + NETDATA_APPS_FILE_FDS,
491 + NETDATA_EBPF_CHART_TYPE_STACKED,
492 + "app.ebpf_file_open_error",
493 + 20221,
494 + update_every);
495 + }
496
495 - if (em->mode < MODE_ENTRY) {
497 ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
497 - NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,
498 - "Fails to close files",
498 + w->clean_name,
499 + "_ebpf_file_closed",
500 + "Files closed.",
501 EBPF_COMMON_DIMENSION_CALL,
500 - NETDATA_APPS_FILE_GROUP,
502 + NETDATA_APPS_FILE_FDS,
503 NETDATA_EBPF_CHART_TYPE_STACKED,
502 - NULL,
503 - 20064,
504 - em->update_every);
504 + "app.ebpf_file_closed",
505 + 20222,
506 + update_every);
507 +
508 + if (em->mode < MODE_ENTRY) {
509 + ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
510 + w->clean_name,
511 + "_ebpf_file_close_error",
512 + "Fails to close files.",
513 + EBPF_COMMON_DIMENSION_CALL,
514 + NETDATA_APPS_FILE_FDS,
515 + NETDATA_EBPF_CHART_TYPE_STACKED,
516 + "app.ebpf_fd_close_error",
517 + 20223,
518 + update_every);
519 + }
520 + w->charts_created &= ~(1<<EBPF_MODULE_FD_IDX);
521 }
522 }
523
@@ -516,6 +532,7 @@ static void ebpf_obsolete_fd_global(ebpf_module_t *em)
532 {
533 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
534 NETDATA_FILE_OPEN_CLOSE_COUNT,
535 + "",
536 "Open and close calls",
537 EBPF_COMMON_DIMENSION_CALL,
538 NETDATA_FILE_GROUP,
@@ -527,6 +544,7 @@ static void ebpf_obsolete_fd_global(ebpf_module_t *em)
544 if (em->mode < MODE_ENTRY) {
545 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
546 NETDATA_FILE_OPEN_ERR_COUNT,
547 + "",
548 "Open fails",
549 EBPF_COMMON_DIMENSION_CALL,
550 NETDATA_FILE_GROUP,
@@ -802,45 +820,30 @@ void ebpf_fd_send_apps_data(ebpf_module_t *em, struct ebpf_target *root)
820 {
821 struct ebpf_target *w;
822 for (w = root; w; w = w->next) {
805 - if (unlikely(w->exposed && w->processes)) {
806 - ebpf_fd_sum_pids(&w->fd, w->root_pid);
807 - }
808 - }
823 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_FD_IDX))))
824 + continue;
825
810 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN);
811 - for (w = root; w; w = w->next) {
812 - if (unlikely(w->exposed && w->processes)) {
813 - write_chart_dimension(w->name, w->fd.open_call);
814 - }
815 - }
816 - write_end_chart();
826 + ebpf_fd_sum_pids(&w->fd, w->root_pid);
827
818 - if (em->mode < MODE_ENTRY) {
819 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR);
820 - for (w = root; w; w = w->next) {
821 - if (unlikely(w->exposed && w->processes)) {
822 - write_chart_dimension(w->name, w->fd.open_err);
823 - }
824 - }
825 - write_end_chart();
826 - }
828 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_file_open");
829 + write_chart_dimension("calls", w->fd.open_call);
830 + ebpf_write_end_chart();
831
828 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSED);
829 - for (w = root; w; w = w->next) {
830 - if (unlikely(w->exposed && w->processes)) {
831 - write_chart_dimension(w->name, w->fd.close_call);
832 + if (em->mode < MODE_ENTRY) {
833 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_file_open_error");
834 + write_chart_dimension("calls", w->fd.open_err);
835 + ebpf_write_end_chart();
836 }
833 - }
834 - write_end_chart();
837
836 - if (em->mode < MODE_ENTRY) {
837 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR);
838 - for (w = root; w; w = w->next) {
839 - if (unlikely(w->exposed && w->processes)) {
840 - write_chart_dimension(w->name, w->fd.close_err);
841 - }
838 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_file_closed");
839 + write_chart_dimension("calls", w->fd.close_call);
840 + ebpf_write_end_chart();
841 +
842 + if (em->mode < MODE_ENTRY) {
843 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_file_close_error");
844 + write_chart_dimension("calls", w->fd.close_err);
845 + ebpf_write_end_chart();
846 }
843 - write_end_chart();
847 }
848 }
849
@@ -933,25 +936,25 @@ static void ebpf_create_specific_fd_charts(char *type, ebpf_module_t *em)
936 */
937 static void ebpf_obsolete_specific_fd_charts(char *type, ebpf_module_t *em)
938 {
936 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "Number of open files",
939 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "", "Number of open files",
940 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
941 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_OPEN_CONTEXT,
942 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5400, em->update_every);
943
944 if (em->mode < MODE_ENTRY) {
942 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "Fails to open files",
945 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "", "Fails to open files",
946 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
947 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_OPEN_ERR_CONTEXT,
948 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5401, em->update_every);
949 }
950
948 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "Files closed",
951 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "", "Files closed",
952 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
953 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_CLOSE_CONTEXT,
954 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5402, em->update_every);
955
956 if (em->mode < MODE_ENTRY) {
954 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "Fails to close files",
957 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "", "Fails to close files",
958 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_FILE_GROUP,
959 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_FD_CLOSE_ERR_CONTEXT,
960 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5403, em->update_every);
@@ -968,24 +971,24 @@ static void ebpf_obsolete_specific_fd_charts(char *type, ebpf_module_t *em)
971 */
972 static void ebpf_send_specific_fd_data(char *type, netdata_fd_stat_t *values, ebpf_module_t *em)
973 {
971 - write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN);
974 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN, "");
975 write_chart_dimension(fd_publish_aggregated[NETDATA_FD_SYSCALL_OPEN].name, (long long)values->open_call);
973 - write_end_chart();
976 + ebpf_write_end_chart();
977
978 if (em->mode < MODE_ENTRY) {
976 - write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR);
979 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "");
980 write_chart_dimension(fd_publish_aggregated[NETDATA_FD_SYSCALL_OPEN].name, (long long)values->open_err);
978 - write_end_chart();
981 + ebpf_write_end_chart();
982 }
983
981 - write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSED);
984 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSED, "");
985 write_chart_dimension(fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE].name, (long long)values->close_call);
983 - write_end_chart();
986 + ebpf_write_end_chart();
987
988 if (em->mode < MODE_ENTRY) {
986 - write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR);
989 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "");
990 write_chart_dimension(fd_publish_aggregated[NETDATA_FD_SYSCALL_CLOSE].name, (long long)values->close_err);
988 - write_end_chart();
991 + ebpf_write_end_chart();
992 }
993 }
994
@@ -1037,40 +1040,40 @@ static void ebpf_create_systemd_fd_charts(ebpf_module_t *em)
1040 static void ebpf_send_systemd_fd_charts(ebpf_module_t *em)
1041 {
1042 ebpf_cgroup_target_t *ect;
1040 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN);
1043 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN, "");
1044 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1045 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1046 write_chart_dimension(ect->name, ect->publish_systemd_fd.open_call);
1047 }
1048 }
1046 - write_end_chart();
1049 + ebpf_write_end_chart();
1050
1051 if (em->mode < MODE_ENTRY) {
1049 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR);
1052 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR, "");
1053 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1054 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1055 write_chart_dimension(ect->name, ect->publish_systemd_fd.open_err);
1056 }
1057 }
1055 - write_end_chart();
1058 + ebpf_write_end_chart();
1059 }
1060
1058 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSED);
1061 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSED, "");
1062 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1063 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1064 write_chart_dimension(ect->name, ect->publish_systemd_fd.close_call);
1065 }
1066 }
1064 - write_end_chart();
1067 + ebpf_write_end_chart();
1068
1069 if (em->mode < MODE_ENTRY) {
1067 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR);
1070 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR, "");
1071 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1072 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1073 write_chart_dimension(ect->name, ect->publish_systemd_fd.close_err);
1074 }
1075 }
1073 - write_end_chart();
1076 + ebpf_write_end_chart();
1077 }
1078 }
1079
@@ -1197,44 +1200,77 @@ static void fd_collector(ebpf_module_t *em)
1200 void ebpf_fd_create_apps_charts(struct ebpf_module *em, void *ptr)
1201 {
1202 struct ebpf_target *root = ptr;
1200 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_FILE_OPEN,
1201 - "Number of open files",
1202 - EBPF_COMMON_DIMENSION_CALL,
1203 - NETDATA_APPS_FILE_GROUP,
1204 - NETDATA_EBPF_CHART_TYPE_STACKED,
1205 - 20061,
1206 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1207 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_FD);
1203 + struct ebpf_target *w;
1204 + int update_every = em->update_every;
1205 + for (w = root; w; w = w->next) {
1206 + if (unlikely(!w->exposed))
1207 + continue;
1208
1209 - if (em->mode < MODE_ENTRY) {
1210 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_FILE_OPEN_ERROR,
1211 - "Fails to open files",
1212 - EBPF_COMMON_DIMENSION_CALL,
1213 - NETDATA_APPS_FILE_GROUP,
1214 - NETDATA_EBPF_CHART_TYPE_STACKED,
1215 - 20062,
1216 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1217 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_FD);
1218 - }
1209 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1210 + w->clean_name,
1211 + "_ebpf_file_open",
1212 + "Number of open files",
1213 + EBPF_COMMON_DIMENSION_CALL,
1214 + NETDATA_APPS_FILE_FDS,
1215 + NETDATA_EBPF_CHART_TYPE_STACKED,
1216 + "app.ebpf_file_open",
1217 + 20220,
1218 + update_every,
1219 + NETDATA_EBPF_MODULE_NAME_FD);
1220 + ebpf_create_chart_labels("app_group", w->name, 0);
1221 + ebpf_commit_label();
1222 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1223 +
1224 + if (em->mode < MODE_ENTRY) {
1225 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1226 + w->clean_name,
1227 + "_ebpf_file_open_error",
1228 + "Fails to open files.",
1229 + EBPF_COMMON_DIMENSION_CALL,
1230 + NETDATA_APPS_FILE_FDS,
1231 + NETDATA_EBPF_CHART_TYPE_STACKED,
1232 + "app.ebpf_file_open_error",
1233 + 20221,
1234 + update_every,
1235 + NETDATA_EBPF_MODULE_NAME_FD);
1236 + ebpf_create_chart_labels("app_group", w->name, 0);
1237 + ebpf_commit_label();
1238 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1239 + }
1240
1220 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_FILE_CLOSED,
1221 - "Files closed",
1222 - EBPF_COMMON_DIMENSION_CALL,
1223 - NETDATA_APPS_FILE_GROUP,
1224 - NETDATA_EBPF_CHART_TYPE_STACKED,
1225 - 20063,
1226 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1227 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_FD);
1241 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1242 + w->clean_name,
1243 + "_ebpf_file_closed",
1244 + "Files closed.",
1245 + EBPF_COMMON_DIMENSION_CALL,
1246 + NETDATA_APPS_FILE_FDS,
1247 + NETDATA_EBPF_CHART_TYPE_STACKED,
1248 + "app.ebpf_file_closed",
1249 + 20222,
1250 + update_every,
1251 + NETDATA_EBPF_MODULE_NAME_FD);
1252 + ebpf_create_chart_labels("app_group", w->name, 0);
1253 + ebpf_commit_label();
1254 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1255 +
1256 + if (em->mode < MODE_ENTRY) {
1257 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1258 + w->clean_name,
1259 + "_ebpf_file_close_error",
1260 + "Fails to close files.",
1261 + EBPF_COMMON_DIMENSION_CALL,
1262 + NETDATA_APPS_FILE_FDS,
1263 + NETDATA_EBPF_CHART_TYPE_STACKED,
1264 + "app.ebpf_file_close_error",
1265 + 20223,
1266 + update_every,
1267 + NETDATA_EBPF_MODULE_NAME_FD);
1268 + ebpf_create_chart_labels("app_group", w->name, 0);
1269 + ebpf_commit_label();
1270 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1271 + }
1272
1229 - if (em->mode < MODE_ENTRY) {
1230 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_FILE_CLOSE_ERROR,
1231 - "Fails to close files",
1232 - EBPF_COMMON_DIMENSION_CALL,
1233 - NETDATA_APPS_FILE_GROUP,
1234 - NETDATA_EBPF_CHART_TYPE_STACKED,
1235 - 20064,
1236 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1237 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_FD);
1273 + w->charts_created |= 1<<EBPF_MODULE_FD_IDX;
1274 }
1275
1276 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
collectors/ebpf.plugin/ebpf_filesystem.c
+8 -2
@@ -351,20 +351,22 @@ static void ebpf_obsolete_fs_charts(int update_every)
351 flags &= ~NETDATA_FILESYSTEM_FLAG_CHART_CREATED;
352
353 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hread.name,
354 + "",
355 efp->hread.title,
356 EBPF_COMMON_DIMENSION_CALL, efp->family_name,
357 NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hread.order, update_every);
358
359 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hwrite.name,
360 + "",
361 efp->hwrite.title,
362 EBPF_COMMON_DIMENSION_CALL, efp->family_name,
363 NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hwrite.order, update_every);
364
363 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hopen.name, efp->hopen.title,
365 + ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hopen.name, "", efp->hopen.title,
366 EBPF_COMMON_DIMENSION_CALL, efp->family_name,
367 NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hopen.order, update_every);
368
367 - ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hadditional.name, efp->hadditional.title,
369 + ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY, efp->hadditional.name,"", efp->hadditional.title,
370 EBPF_COMMON_DIMENSION_CALL, efp->family_name,
371 NULL, NETDATA_EBPF_CHART_TYPE_STACKED, efp->hadditional.order,
372 update_every);
@@ -671,6 +673,7 @@ static void ebpf_obsolete_filesystem_global(ebpf_module_t *em)
673
674 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
675 efp->hread.name,
676 + "",
677 efp->hread.title,
678 EBPF_COMMON_DIMENSION_CALL,
679 efp->family_name,
@@ -681,6 +684,7 @@ static void ebpf_obsolete_filesystem_global(ebpf_module_t *em)
684
685 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
686 efp->hwrite.name,
687 + "",
688 efp->hwrite.title,
689 EBPF_COMMON_DIMENSION_CALL,
690 efp->family_name,
@@ -691,6 +695,7 @@ static void ebpf_obsolete_filesystem_global(ebpf_module_t *em)
695
696 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
697 efp->hopen.name,
698 + "",
699 efp->hopen.title,
700 EBPF_COMMON_DIMENSION_CALL,
701 efp->family_name,
@@ -701,6 +706,7 @@ static void ebpf_obsolete_filesystem_global(ebpf_module_t *em)
706
707 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
708 efp->hadditional.name,
709 + "",
710 efp->hadditional.title,
711 EBPF_COMMON_DIMENSION_CALL,
712 efp->family_name,
collectors/ebpf.plugin/ebpf_hardirq.c
+3 -2
@@ -226,6 +226,7 @@ static void ebpf_obsolete_hardirq_global(ebpf_module_t *em)
226 {
227 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
228 "hardirq_latency",
229 + "",
230 "Hardware IRQ latency",
231 EBPF_COMMON_DIMENSION_MILLISECONDS,
232 "interrupts",
@@ -593,10 +594,10 @@ static void hardirq_collector(ebpf_module_t *em)
594 pthread_mutex_lock(&lock);
595
596 // write dims now for all hitherto discovered IRQs.
596 - write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, "hardirq_latency");
597 + ebpf_write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, "hardirq_latency", "");
598 avl_traverse_lock(&hardirq_pub, hardirq_write_dims, NULL);
599 hardirq_write_static_dims();
599 - write_end_chart();
600 + ebpf_write_end_chart();
601
602 pthread_mutex_unlock(&lock);
603
collectors/ebpf.plugin/ebpf_mdflush.c
+3 -2
@@ -140,6 +140,7 @@ static void ebpf_obsolete_mdflush_global(ebpf_module_t *em)
140 {
141 ebpf_write_chart_obsolete("mdstat",
142 "mdstat_flush",
143 + "",
144 "MD flushes",
145 "flushes",
146 "flush (eBPF)",
@@ -355,9 +356,9 @@ static void mdflush_collector(ebpf_module_t *em)
356 mdflush_read_count_map(maps_per_core);
357 pthread_mutex_lock(&lock);
358 // write dims now for all hitherto discovered devices.
358 - write_begin_chart("mdstat", "mdstat_flush");
359 + ebpf_write_begin_chart("mdstat", "mdstat_flush", "");
360 avl_traverse_lock(&mdflush_pub, mdflush_write_dims, NULL);
360 - write_end_chart();
361 + ebpf_write_end_chart();
362
363 pthread_mutex_unlock(&lock);
364
collectors/ebpf.plugin/ebpf_mount.c
+2
@@ -233,6 +233,7 @@ static void ebpf_obsolete_mount_global(ebpf_module_t *em)
233 {
234 ebpf_write_chart_obsolete(NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,
235 NETDATA_EBPF_MOUNT_CALLS,
236 + "",
237 "Calls to mount and umount syscalls",
238 EBPF_COMMON_DIMENSION_CALL,
239 NETDATA_EBPF_MOUNT_FAMILY,
@@ -243,6 +244,7 @@ static void ebpf_obsolete_mount_global(ebpf_module_t *em)
244
245 ebpf_write_chart_obsolete(NETDATA_EBPF_MOUNT_GLOBAL_FAMILY,
246 NETDATA_EBPF_MOUNT_ERRORS,
247 + "",
248 "Errors to mount and umount file systems",
249 EBPF_COMMON_DIMENSION_CALL,
250 NETDATA_EBPF_MOUNT_FAMILY,
collectors/ebpf.plugin/ebpf_oomkill.c
+58 -31
@@ -57,6 +57,7 @@ static void ebpf_obsolete_oomkill_services(ebpf_module_t *em)
57 {
58 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
59 NETDATA_OOMKILL_CHART,
60 + "",
61 "OOM kills. This chart is provided by eBPF plugin.",
62 EBPF_COMMON_DIMENSION_KILLS,
63 NETDATA_EBPF_MEMORY_GROUP,
@@ -98,15 +99,25 @@ static inline void ebpf_obsolete_oomkill_cgroup_charts(ebpf_module_t *em)
99 */
100 static void ebpf_obsolete_oomkill_apps(ebpf_module_t *em)
101 {
101 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
102 - NETDATA_OOMKILL_CHART,
103 - "OOM kills",
104 - EBPF_COMMON_DIMENSION_KILLS,
105 - "mem",
106 - NETDATA_EBPF_CHART_TYPE_STACKED,
107 - NULL,
108 - 20020,
109 - em->update_every);
102 + struct ebpf_target *w;
103 + int update_every = em->update_every;
104 + for (w = apps_groups_root_target; w; w = w->next) {
105 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_OOMKILL_IDX))))
106 + continue;
107 +
108 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
109 + w->clean_name,
110 + "_app_oomkill",
111 + "OOM kills.",
112 + EBPF_COMMON_DIMENSION_KILLS,
113 + NETDATA_EBPF_MEMORY_GROUP,
114 + NETDATA_EBPF_CHART_TYPE_STACKED,
115 + "ebpf.app_oomkill",
116 + 20020,
117 + update_every);
118 +
119 + w->charts_created &= ~(1<<EBPF_MODULE_OOMKILL_IDX);
120 + }
121 }
122
123 /**
@@ -150,8 +161,11 @@ static void oomkill_write_data(int32_t *keys, uint32_t total)
161 // for each app, see if it was OOM killed. record as 1 if so otherwise 0.
162 struct ebpf_target *w;
163 for (w = apps_groups_root_target; w != NULL; w = w->next) {
153 - if (likely(w->exposed && w->processes)) {
154 - bool was_oomkilled = false;
164 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_OOMKILL_IDX))))
165 + continue;
166 +
167 + bool was_oomkilled = false;
168 + if (total) {
169 struct ebpf_pid_on_target *pids = w->root_pid;
170 while (pids) {
171 uint32_t j;
@@ -165,10 +179,11 @@ static void oomkill_write_data(int32_t *keys, uint32_t total)
179 }
180 pids = pids->next;
181 }
168 -
169 - write_dim:;
170 - write_chart_dimension(w->name, was_oomkilled);
182 }
183 +write_dim:
184 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_oomkill");
185 + write_chart_dimension(EBPF_COMMON_DIMENSION_KILLS, was_oomkilled);
186 + ebpf_write_end_chart();
187 }
188
189 // for any remaining keys for which we couldn't find a group, this could be
@@ -231,14 +246,14 @@ static void ebpf_create_systemd_oomkill_charts(int update_every)
246 static void ebpf_send_systemd_oomkill_charts()
247 {
248 ebpf_cgroup_target_t *ect;
234 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_OOMKILL_CHART);
249 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_OOMKILL_CHART, "");
250 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
251 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
252 write_chart_dimension(ect->name, (long long) ect->oomkill);
253 ect->oomkill = 0;
254 }
255 }
241 - write_end_chart();
256 + ebpf_write_end_chart();
257 }
258
259 /*
@@ -251,9 +266,9 @@ static void ebpf_send_systemd_oomkill_charts()
266 */
267 static void ebpf_send_specific_oomkill_data(char *type, int value)
268 {
254 - write_begin_chart(type, NETDATA_OOMKILL_CHART);
269 + ebpf_write_begin_chart(type, NETDATA_OOMKILL_CHART, "");
270 write_chart_dimension(oomkill_publish_aggregated.name, (long long)value);
256 - write_end_chart();
271 + ebpf_write_end_chart();
272 }
273
274 /**
@@ -266,7 +281,7 @@ static void ebpf_send_specific_oomkill_data(char *type, int value)
281 */
282 static void ebpf_obsolete_specific_oomkill_charts(char *type, int update_every)
283 {
269 - ebpf_write_chart_obsolete(type, NETDATA_OOMKILL_CHART, "OOM kills. This chart is provided by eBPF plugin.",
284 + ebpf_write_chart_obsolete(type, NETDATA_OOMKILL_CHART, "", "OOM kills. This chart is provided by eBPF plugin.",
285 EBPF_COMMON_DIMENSION_KILLS, NETDATA_EBPF_MEMORY_GROUP,
286 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_OOMKILLS_CONTEXT,
287 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5600, update_every);
@@ -430,7 +445,6 @@ static void oomkill_collector(ebpf_module_t *em)
445 uint32_t count = oomkill_read_data(keys);
446 if (!count) {
447 running_time = ebpf_update_oomkill_period(running_time, em);
433 - continue;
448 }
449
450 stats[NETDATA_CONTROLLER_PID_TABLE_ADD] += (uint64_t) count;
@@ -438,16 +452,14 @@ static void oomkill_collector(ebpf_module_t *em)
452
453 pthread_mutex_lock(&collect_data_mutex);
454 pthread_mutex_lock(&lock);
441 - if (cgroups) {
455 + if (cgroups && count) {
456 ebpf_update_oomkill_cgroup(keys, count);
457 // write everything from the ebpf map.
458 ebpf_oomkill_send_cgroup_data(update_every);
459 }
460
461 if (em->apps_charts & NETDATA_EBPF_APPS_FLAG_CHART_CREATED) {
448 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_OOMKILL_CHART);
462 oomkill_write_data(keys, count);
450 - write_end_chart();
463 }
464 pthread_mutex_unlock(&lock);
465 pthread_mutex_unlock(&collect_data_mutex);
@@ -466,14 +478,29 @@ static void oomkill_collector(ebpf_module_t *em)
478 void ebpf_oomkill_create_apps_charts(struct ebpf_module *em, void *ptr)
479 {
480 struct ebpf_target *root = ptr;
469 - ebpf_create_charts_on_apps(NETDATA_OOMKILL_CHART,
470 - "OOM kills",
471 - EBPF_COMMON_DIMENSION_KILLS,
472 - "mem",
473 - NETDATA_EBPF_CHART_TYPE_STACKED,
474 - 20020,
475 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
476 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_OOMKILL);
481 + struct ebpf_target *w;
482 + int update_every = em->update_every;
483 + for (w = root; w; w = w->next) {
484 + if (unlikely(!w->exposed))
485 + continue;
486 +
487 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
488 + w->clean_name,
489 + "_ebpf_oomkill",
490 + "OOM kills.",
491 + EBPF_COMMON_DIMENSION_KILLS,
492 + NETDATA_EBPF_MEMORY_GROUP,
493 + NETDATA_EBPF_CHART_TYPE_STACKED,
494 + "app.ebpf_oomkill",
495 + 20020,
496 + update_every,
497 + NETDATA_EBPF_MODULE_NAME_OOMKILL);
498 + ebpf_create_chart_labels("app_group", w->name, 0);
499 + ebpf_commit_label();
500 + fprintf(stdout, "DIMENSION kills '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
501 +
502 + w->charts_created |= 1<<EBPF_MODULE_OOMKILL_IDX;
503 + }
504
505 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
506 }
collectors/ebpf.plugin/ebpf_process.c
+208 -161
@@ -116,12 +116,12 @@ static void ebpf_update_global_publish(netdata_publish_syscall_t *publish, netda
116 */
117 static void write_status_chart(char *family, netdata_publish_vfs_common_t *pvc)
118 {
119 - write_begin_chart(family, NETDATA_PROCESS_STATUS_NAME);
119 + ebpf_write_begin_chart(family, NETDATA_PROCESS_STATUS_NAME, "");
120
121 write_chart_dimension(status[0], (long long)pvc->running);
122 write_chart_dimension(status[1], (long long)pvc->zombie);
123
124 - write_end_chart();
124 + ebpf_write_end_chart();
125 }
126
127 /**
@@ -201,56 +201,43 @@ void ebpf_process_remove_pids()
201 void ebpf_process_send_apps_data(struct ebpf_target *root, ebpf_module_t *em)
202 {
203 struct ebpf_target *w;
204 - collected_number value;
204 + // This algorithm is improved in https://github.com/netdata/netdata/pull/16030
205 + collected_number values[5];
206
206 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_TASK_PROCESS);
207 for (w = root; w; w = w->next) {
208 - if (unlikely(w->exposed && w->processes)) {
209 - value = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, create_process));
210 - write_chart_dimension(w->name, value);
211 - }
212 - }
213 - write_end_chart();
214 -
215 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_TASK_THREAD);
216 - for (w = root; w; w = w->next) {
217 - if (unlikely(w->exposed && w->processes)) {
218 - value = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, create_thread));
219 - write_chart_dimension(w->name, value);
220 - }
221 - }
222 - write_end_chart();
208 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_PROCESS_IDX))))
209 + continue;
210
224 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_TASK_EXIT);
225 - for (w = root; w; w = w->next) {
226 - if (unlikely(w->exposed && w->processes)) {
227 - value = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t,
211 + values[0] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, create_process));
212 + values[1] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t, create_thread));
213 + values[2] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t,
214 exit_call));
229 - write_chart_dimension(w->name, value);
230 - }
231 - }
232 - write_end_chart();
233 -
234 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_TASK_CLOSE);
235 - for (w = root; w; w = w->next) {
236 - if (unlikely(w->exposed && w->processes)) {
237 - value = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t,
215 + values[3] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t,
216 release_call));
239 - write_chart_dimension(w->name, value);
240 - }
241 - }
242 - write_end_chart();
217 + values[4] = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t,
218 + task_err));
219
244 - if (em->mode < MODE_ENTRY) {
245 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_TASK_ERROR);
246 - for (w = root; w; w = w->next) {
247 - if (unlikely(w->exposed && w->processes)) {
248 - value = ebpf_process_sum_values_for_pids(w->root_pid, offsetof(ebpf_process_stat_t,
249 - task_err));
250 - write_chart_dimension(w->name, value);
251 - }
220 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_process_start");
221 + write_chart_dimension("calls", values[0]);
222 + ebpf_write_end_chart();
223 +
224 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_thread_start");
225 + write_chart_dimension("calls", values[1]);
226 + ebpf_write_end_chart();
227 +
228 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_task_exit");
229 + write_chart_dimension("calls", values[2]);
230 + ebpf_write_end_chart();
231 +
232 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_task_released");
233 + write_chart_dimension("calls", values[3]);
234 + ebpf_write_end_chart();
235 +
236 + if (em->mode < MODE_ENTRY) {
237 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_task_error");
238 + write_chart_dimension("calls", values[4]);
239 + ebpf_write_end_chart();
240 }
253 - write_end_chart();
241 }
242
243 ebpf_process_remove_pids();
@@ -433,52 +420,89 @@ static void ebpf_create_global_charts(ebpf_module_t *em)
420 void ebpf_process_create_apps_charts(struct ebpf_module *em, void *ptr)
421 {
422 struct ebpf_target *root = ptr;
436 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_TASK_PROCESS,
437 - "Process started",
438 - EBPF_COMMON_DIMENSION_CALL,
439 - NETDATA_PROCESS_GROUP,
440 - NETDATA_EBPF_CHART_TYPE_STACKED,
441 - 20065,
442 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
443 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
444 -
445 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_TASK_THREAD,
446 - "Threads started",
447 - EBPF_COMMON_DIMENSION_CALL,
448 - NETDATA_PROCESS_GROUP,
449 - NETDATA_EBPF_CHART_TYPE_STACKED,
450 - 20066,
451 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
452 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
453 -
454 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_TASK_EXIT,
455 - "Tasks starts exit process.",
456 - EBPF_COMMON_DIMENSION_CALL,
457 - NETDATA_PROCESS_GROUP,
458 - NETDATA_EBPF_CHART_TYPE_STACKED,
459 - 20067,
460 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
461 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
462 -
463 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_TASK_CLOSE,
464 - "Tasks closed",
465 - EBPF_COMMON_DIMENSION_CALL,
466 - NETDATA_PROCESS_GROUP,
467 - NETDATA_EBPF_CHART_TYPE_STACKED,
468 - 20068,
469 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
470 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
423 + struct ebpf_target *w;
424 + int update_every = em->update_every;
425 + for (w = root; w; w = w->next) {
426 + if (unlikely(!w->exposed))
427 + continue;
428
472 - if (em->mode < MODE_ENTRY) {
473 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_TASK_ERROR,
474 - "Errors to create process or threads.",
475 - EBPF_COMMON_DIMENSION_CALL,
476 - NETDATA_PROCESS_GROUP,
477 - NETDATA_EBPF_CHART_TYPE_STACKED,
478 - 20069,
479 - ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX],
480 - root,
481 - em->update_every, NETDATA_EBPF_MODULE_NAME_PROCESS);
429 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
430 + w->clean_name,
431 + "_ebpf_process_start",
432 + "Process started.",
433 + EBPF_COMMON_DIMENSION_CALL,
434 + NETDATA_PROCESS_GROUP,
435 + NETDATA_EBPF_CHART_TYPE_STACKED,
436 + "app.ebpf_process_start",
437 + 20161,
438 + update_every,
439 + NETDATA_EBPF_MODULE_NAME_PROCESS);
440 + ebpf_create_chart_labels("app_group", w->name, 0);
441 + ebpf_commit_label();
442 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
443 +
444 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
445 + w->clean_name,
446 + "_ebpf_thread_start",
447 + "Threads started.",
448 + EBPF_COMMON_DIMENSION_CALL,
449 + NETDATA_PROCESS_GROUP,
450 + NETDATA_EBPF_CHART_TYPE_STACKED,
451 + "app.ebpf_thread_start",
452 + 20162,
453 + update_every,
454 + NETDATA_EBPF_MODULE_NAME_PROCESS);
455 + ebpf_create_chart_labels("app_group", w->name, 0);
456 + ebpf_commit_label();
457 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
458 +
459 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
460 + w->clean_name,
461 + "_ebpf_task_exit",
462 + "Tasks starts exit process.",
463 + EBPF_COMMON_DIMENSION_CALL,
464 + NETDATA_PROCESS_GROUP,
465 + NETDATA_EBPF_CHART_TYPE_STACKED,
466 + "app.ebpf_task_exit",
467 + 20163,
468 + update_every,
469 + NETDATA_EBPF_MODULE_NAME_PROCESS);
470 + ebpf_create_chart_labels("app_group", w->name, 0);
471 + ebpf_commit_label();
472 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
473 +
474 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
475 + w->clean_name,
476 + "_ebpf_task_released",
477 + "Tasks released.",
478 + EBPF_COMMON_DIMENSION_CALL,
479 + NETDATA_PROCESS_GROUP,
480 + NETDATA_EBPF_CHART_TYPE_STACKED,
481 + "app.ebpf_task_released",
482 + 20164,
483 + update_every,
484 + NETDATA_EBPF_MODULE_NAME_PROCESS);
485 + ebpf_create_chart_labels("app_group", w->name, 0);
486 + ebpf_commit_label();
487 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
488 +
489 + if (em->mode < MODE_ENTRY) {
490 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
491 + w->clean_name,
492 + "_ebpf_task_error",
493 + "Errors to create process or threads.",
494 + EBPF_COMMON_DIMENSION_CALL,
495 + NETDATA_PROCESS_GROUP,
496 + NETDATA_EBPF_CHART_TYPE_STACKED,
497 + "app.ebpf_task_error",
498 + 20165,
499 + update_every,
500 + NETDATA_EBPF_MODULE_NAME_PROCESS);
501 + ebpf_create_chart_labels("app_group", w->name, 0);
502 + ebpf_commit_label();
503 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_ABSOLUTE_IDX]);
504 + }
505 + w->charts_created |= 1<<EBPF_MODULE_PROCESS_IDX;
506 }
507
508 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
@@ -503,6 +527,7 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
527 {
528 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
529 NETDATA_SYSCALL_APPS_TASK_PROCESS,
530 + "",
531 "Process started",
532 EBPF_COMMON_DIMENSION_CALL,
533 NETDATA_APPS_PROCESS_GROUP,
@@ -513,6 +538,7 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
538
539 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
540 NETDATA_SYSCALL_APPS_TASK_THREAD,
541 + "",
542 "Threads started",
543 EBPF_COMMON_DIMENSION_CALL,
544 NETDATA_APPS_PROCESS_GROUP,
@@ -523,6 +549,7 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
549
550 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
551 NETDATA_SYSCALL_APPS_TASK_CLOSE,
552 + "",
553 "Tasks starts exit process.",
554 EBPF_COMMON_DIMENSION_CALL,
555 NETDATA_APPS_PROCESS_GROUP,
@@ -533,6 +560,7 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
560
561 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
562 NETDATA_SYSCALL_APPS_TASK_EXIT,
563 + "",
564 "Tasks closed",
565 EBPF_COMMON_DIMENSION_CALL,
566 NETDATA_APPS_PROCESS_GROUP,
@@ -544,6 +572,7 @@ static void ebpf_obsolete_process_services(ebpf_module_t *em)
572 if (em->mode < MODE_ENTRY) {
573 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
574 NETDATA_SYSCALL_APPS_TASK_ERROR,
575 + "",
576 "Errors to create process or threads.",
577 EBPF_COMMON_DIMENSION_CALL,
578 NETDATA_APPS_PROCESS_GROUP,
@@ -585,56 +614,70 @@ static inline void ebpf_obsolete_process_cgroup_charts(ebpf_module_t *em) {
614 */
615 void ebpf_obsolete_process_apps_charts(struct ebpf_module *em)
616 {
588 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
589 - NETDATA_SYSCALL_APPS_TASK_PROCESS,
590 - "Process started",
591 - EBPF_COMMON_DIMENSION_CALL,
592 - NETDATA_PROCESS_GROUP,
593 - NETDATA_EBPF_CHART_TYPE_STACKED,
594 - NULL,
595 - 20065,
596 - em->update_every);
597 -
598 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
599 - NETDATA_SYSCALL_APPS_TASK_THREAD,
600 - "Threads started",
601 - EBPF_COMMON_DIMENSION_CALL,
602 - NETDATA_PROCESS_GROUP,
603 - NETDATA_EBPF_CHART_TYPE_STACKED,
604 - NULL,
605 - 20066,
606 - em->update_every);
607 -
608 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
609 - NETDATA_SYSCALL_APPS_TASK_EXIT,
610 - "Tasks starts exit process.",
611 - EBPF_COMMON_DIMENSION_CALL,
612 - NETDATA_PROCESS_GROUP,
613 - NETDATA_EBPF_CHART_TYPE_STACKED,
614 - NULL,
615 - 20067,
616 - em->update_every);
617 -
618 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
619 - NETDATA_SYSCALL_APPS_TASK_CLOSE,
620 - "Tasks closed",
621 - EBPF_COMMON_DIMENSION_CALL,
622 - NETDATA_PROCESS_GROUP,
623 - NETDATA_EBPF_CHART_TYPE_STACKED,
624 - NULL,
625 - 20068,
626 - em->update_every);
617 + struct ebpf_target *w;
618 + int update_every = em->update_every;
619 + for (w = apps_groups_root_target; w; w = w->next) {
620 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_PROCESS_IDX))))
621 + continue;
622
628 - if (em->mode < MODE_ENTRY) {
629 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
630 - NETDATA_SYSCALL_APPS_TASK_ERROR,
631 - "Errors to create process or threads.",
623 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
624 + w->clean_name,
625 + "_ebpf_process_start",
626 + "Process started.",
627 EBPF_COMMON_DIMENSION_CALL,
628 NETDATA_PROCESS_GROUP,
629 NETDATA_EBPF_CHART_TYPE_STACKED,
635 - NULL,
636 - 20069,
637 - em->update_every);
630 + "app.ebpf_process_start",
631 + 20161,
632 + update_every);
633 +
634 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
635 + w->clean_name,
636 + "_ebpf_thread_start",
637 + "Threads started.",
638 + EBPF_COMMON_DIMENSION_CALL,
639 + NETDATA_PROCESS_GROUP,
640 + NETDATA_EBPF_CHART_TYPE_STACKED,
641 + "app.ebpf_thread_start",
642 + 20162,
643 + update_every);
644 +
645 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
646 + w->clean_name,
647 + "_ebpf_task_exit",
648 + "Tasks starts exit process.",
649 + EBPF_COMMON_DIMENSION_CALL,
650 + NETDATA_PROCESS_GROUP,
651 + NETDATA_EBPF_CHART_TYPE_STACKED,
652 + "app.ebpf_task_exit",
653 + 20163,
654 + update_every);
655 +
656 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
657 + w->clean_name,
658 + "_ebpf_task_released",
659 + "Tasks released.",
660 + EBPF_COMMON_DIMENSION_CALL,
661 + NETDATA_PROCESS_GROUP,
662 + NETDATA_EBPF_CHART_TYPE_STACKED,
663 + "app.ebpf_task_released",
664 + 20164,
665 + update_every);
666 +
667 + if (em->mode < MODE_ENTRY) {
668 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
669 + w->clean_name,
670 + "_ebpf_task_error",
671 + "Errors to create process or threads.",
672 + EBPF_COMMON_DIMENSION_CALL,
673 + NETDATA_PROCESS_GROUP,
674 + NETDATA_EBPF_CHART_TYPE_STACKED,
675 + "app.ebpf_task_error",
676 + 20165,
677 + update_every);
678 + }
679 +
680 + w->charts_created &= ~(1<<EBPF_MODULE_PROCESS_IDX);
681 }
682 }
683
@@ -649,6 +692,7 @@ static void ebpf_obsolete_process_global(ebpf_module_t *em)
692 {
693 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
694 NETDATA_PROCESS_SYSCALL,
695 + "",
696 "Start process",
697 EBPF_COMMON_DIMENSION_CALL,
698 NETDATA_PROCESS_GROUP,
@@ -659,6 +703,7 @@ static void ebpf_obsolete_process_global(ebpf_module_t *em)
703
704 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
705 NETDATA_EXIT_SYSCALL,
706 + "",
707 "Exit process",
708 EBPF_COMMON_DIMENSION_CALL,
709 NETDATA_PROCESS_GROUP,
@@ -669,6 +714,7 @@ static void ebpf_obsolete_process_global(ebpf_module_t *em)
714
715 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
716 NETDATA_PROCESS_STATUS_NAME,
717 + "",
718 "Process not closed",
719 EBPF_COMMON_DIMENSION_DIFFERENCE,
720 NETDATA_PROCESS_GROUP,
@@ -680,6 +726,7 @@ static void ebpf_obsolete_process_global(ebpf_module_t *em)
726 if (em->mode < MODE_ENTRY) {
727 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
728 NETDATA_PROCESS_ERROR_NAME,
729 + "",
730 "Fails to create process",
731 EBPF_COMMON_DIMENSION_CALL,
732 NETDATA_PROCESS_GROUP,
@@ -819,31 +866,31 @@ static void ebpf_process_sum_cgroup_pids(ebpf_process_stat_t *ps, struct pid_on_
866 */
867 static void ebpf_send_specific_process_data(char *type, ebpf_process_stat_t *values, ebpf_module_t *em)
868 {
822 - write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_PROCESS);
869 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "");
870 write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_FORK].name,
871 (long long) values->create_process);
825 - write_end_chart();
872 + ebpf_write_end_chart();
873
827 - write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_THREAD);
874 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "");
875 write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_CLONE].name,
876 (long long) values->create_thread);
830 - write_end_chart();
877 + ebpf_write_end_chart();
878
832 - write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_EXIT);
879 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "");
880 write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT].name,
881 (long long) values->release_call);
835 - write_end_chart();
882 + ebpf_write_end_chart();
883
837 - write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_CLOSE);
884 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "");
885 write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_RELEASE_TASK].name,
886 (long long) values->release_call);
840 - write_end_chart();
887 + ebpf_write_end_chart();
888
889 if (em->mode < MODE_ENTRY) {
843 - write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_ERROR);
890 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "");
891 write_chart_dimension(process_publish_aggregated[NETDATA_KEY_PUBLISH_PROCESS_EXIT].name,
892 (long long) values->task_err);
846 - write_end_chart();
893 + ebpf_write_end_chart();
894 }
895 }
896
@@ -909,28 +956,28 @@ static void ebpf_create_specific_process_charts(char *type, ebpf_module_t *em)
956 */
957 static void ebpf_obsolete_specific_process_charts(char *type, ebpf_module_t *em)
958 {
912 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "Process started",
959 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_PROCESS, "", "Process started",
960 EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,
961 NETDATA_CGROUP_PROCESS_CREATE_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5000,
962 em->update_every);
963
917 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "Threads started",
964 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_THREAD, "", "Threads started",
965 EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,
966 NETDATA_CGROUP_THREAD_CREATE_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5001,
967 em->update_every);
968
922 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_EXIT,"Tasks starts exit process.",
969 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_EXIT, "","Tasks starts exit process.",
970 EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,
971 NETDATA_CGROUP_PROCESS_EXIT_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5002,
972 em->update_every);
973
927 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_CLOSE,"Tasks closed",
974 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_CLOSE, "","Tasks closed",
975 EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,
976 NETDATA_CGROUP_PROCESS_CLOSE_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5003,
977 em->update_every);
978
979 if (em->mode < MODE_ENTRY) {
933 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_ERROR,"Errors to create process or threads.",
980 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_TASK_ERROR, "","Errors to create process or threads.",
981 EBPF_COMMON_DIMENSION_CALL, NETDATA_PROCESS_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,
982 NETDATA_CGROUP_PROCESS_ERROR_CONTEXT, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5004,
983 em->update_every);
@@ -989,46 +1036,46 @@ static void ebpf_create_systemd_process_charts(ebpf_module_t *em)
1036 static void ebpf_send_systemd_process_charts(ebpf_module_t *em)
1037 {
1038 ebpf_cgroup_target_t *ect;
992 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_PROCESS);
1039 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_PROCESS, "");
1040 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1041 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1042 write_chart_dimension(ect->name, ect->publish_systemd_ps.create_process);
1043 }
1044 }
998 - write_end_chart();
1045 + ebpf_write_end_chart();
1046
1000 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_THREAD);
1047 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_THREAD, "");
1048 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1049 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1050 write_chart_dimension(ect->name, ect->publish_systemd_ps.create_thread);
1051 }
1052 }
1006 - write_end_chart();
1053 + ebpf_write_end_chart();
1054
1008 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_EXIT);
1055 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_EXIT, "");
1056 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1057 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1058 write_chart_dimension(ect->name, ect->publish_systemd_ps.exit_call);
1059 }
1060 }
1014 - write_end_chart();
1061 + ebpf_write_end_chart();
1062
1016 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_CLOSE);
1063 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_CLOSE, "");
1064 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1065 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1066 write_chart_dimension(ect->name, ect->publish_systemd_ps.release_call);
1067 }
1068 }
1022 - write_end_chart();
1069 + ebpf_write_end_chart();
1070
1071 if (em->mode < MODE_ENTRY) {
1025 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_ERROR);
1072 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_TASK_ERROR, "");
1073 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1074 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1075 write_chart_dimension(ect->name, ect->publish_systemd_ps.task_err);
1076 }
1077 }
1031 - write_end_chart();
1078 + ebpf_write_end_chart();
1079 }
1080 }
1081
collectors/ebpf.plugin/ebpf_shm.c
+176 -136
@@ -305,7 +305,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
305 {
306 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
307 NETDATA_SHMGET_CHART,
308 - "Calls to syscall <code>shmget(2)</code>.",
308 + "",
309 + "Calls to syscall shmget(2).",
310 EBPF_COMMON_DIMENSION_CALL,
311 NETDATA_APPS_IPC_SHM_GROUP,
312 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -315,7 +316,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
316
317 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
318 NETDATA_SHMAT_CHART,
318 - "Calls to syscall <code>shmat(2)</code>.",
319 + "",
320 + "Calls to syscall shmat(2).",
321 EBPF_COMMON_DIMENSION_CALL,
322 NETDATA_APPS_IPC_SHM_GROUP,
323 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -325,7 +327,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
327
328 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
329 NETDATA_SHMDT_CHART,
328 - "Calls to syscall <code>shmdt(2)</code>.",
330 + "",
331 + "Calls to syscall shmdt(2).",
332 EBPF_COMMON_DIMENSION_CALL,
333 NETDATA_APPS_IPC_SHM_GROUP,
334 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -335,7 +338,8 @@ static void ebpf_obsolete_shm_services(ebpf_module_t *em)
338
339 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
340 NETDATA_SHMCTL_CHART,
338 - "Calls to syscall <code>shmctl(2)</code>.",
341 + "",
342 + "Calls to syscall shmctl(2).",
343 EBPF_COMMON_DIMENSION_CALL,
344 NETDATA_APPS_IPC_SHM_GROUP,
345 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -375,45 +379,58 @@ static inline void ebpf_obsolete_shm_cgroup_charts(ebpf_module_t *em) {
379 */
380 void ebpf_obsolete_shm_apps_charts(struct ebpf_module *em)
381 {
378 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
379 - NETDATA_SHMGET_CHART,
380 - "Calls to syscall <code>shmget(2)</code>.",
381 - EBPF_COMMON_DIMENSION_CALL,
382 - NETDATA_APPS_IPC_SHM_GROUP,
383 - NETDATA_EBPF_CHART_TYPE_STACKED,
384 - NULL,
385 - 20191,
386 - em->update_every);
382 + struct ebpf_target *w;
383 + int update_every = em->update_every;
384 + for (w = apps_groups_root_target; w; w = w->next) {
385 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SHM_IDX))))
386 + continue;
387
388 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
389 - NETDATA_SHMAT_CHART,
390 - "Calls to syscall <code>shmat(2)</code>.",
391 - EBPF_COMMON_DIMENSION_CALL,
392 - NETDATA_APPS_IPC_SHM_GROUP,
393 - NETDATA_EBPF_CHART_TYPE_STACKED,
394 - NULL,
395 - 20192,
396 - em->update_every);
388 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
389 + w->clean_name,
390 + "_ebpf_shmget_call",
391 + "Calls to syscall shmget(2).",
392 + EBPF_COMMON_DIMENSION_CALL,
393 + NETDATA_APPS_IPC_SHM_GROUP,
394 + NETDATA_EBPF_CHART_TYPE_STACKED,
395 + "app.ebpf_shmget_call",
396 + 20191,
397 + update_every);
398
398 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
399 - NETDATA_SHMDT_CHART,
400 - "Calls to syscall <code>shmdt(2)</code>.",
401 - EBPF_COMMON_DIMENSION_CALL,
402 - NETDATA_APPS_IPC_SHM_GROUP,
403 - NETDATA_EBPF_CHART_TYPE_STACKED,
404 - NULL,
405 - 20193,
406 - em->update_every);
399 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
400 + w->clean_name,
401 + "_ebpf_shmat_call",
402 + "Calls to syscall shmat(2).",
403 + EBPF_COMMON_DIMENSION_CALL,
404 + NETDATA_APPS_IPC_SHM_GROUP,
405 + NETDATA_EBPF_CHART_TYPE_STACKED,
406 + "app.ebpf_shmat_call",
407 + 20192,
408 + update_every);
409
408 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
409 - NETDATA_SHMCTL_CHART,
410 - "Calls to syscall <code>shmctl(2)</code>.",
411 - EBPF_COMMON_DIMENSION_CALL,
412 - NETDATA_APPS_IPC_SHM_GROUP,
413 - NETDATA_EBPF_CHART_TYPE_STACKED,
414 - NULL,
415 - 20194,
416 - em->update_every);
410 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
411 + w->clean_name,
412 + "_ebpf_shmdt_call",
413 + "Calls to syscall shmdt(2).",
414 + EBPF_COMMON_DIMENSION_CALL,
415 + NETDATA_APPS_IPC_SHM_GROUP,
416 + NETDATA_EBPF_CHART_TYPE_STACKED,
417 + "app.ebpf_shmdt_call",
418 + 20193,
419 + update_every);
420 +
421 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
422 + w->clean_name,
423 + "_ebpf_shmctl_call",
424 + "Calls to syscall shmctl(2).",
425 + EBPF_COMMON_DIMENSION_CALL,
426 + NETDATA_APPS_IPC_SHM_GROUP,
427 + NETDATA_EBPF_CHART_TYPE_STACKED,
428 + "app.ebpf_shmctl_call",
429 + 20194,
430 + update_every);
431 +
432 + w->charts_created &= ~(1<<EBPF_MODULE_SHM_IDX);
433 + }
434 }
435
436 /**
@@ -427,6 +444,7 @@ static void ebpf_obsolete_shm_global(ebpf_module_t *em)
444 {
445 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
446 NETDATA_SHM_GLOBAL_CHART,
447 + "",
448 "Calls to shared memory system calls",
449 EBPF_COMMON_DIMENSION_CALL,
450 NETDATA_SYSTEM_IPC_SHM_SUBMENU,
@@ -621,7 +639,7 @@ static void read_shm_apps_table(int maps_per_core)
639 */
640 static void shm_send_global()
641 {
624 - write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, NETDATA_SHM_GLOBAL_CHART);
642 + ebpf_write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, NETDATA_SHM_GLOBAL_CHART, "");
643 write_chart_dimension(
644 shm_publish_aggregated[NETDATA_KEY_SHMGET_CALL].dimension,
645 (long long) shm_hash_values[NETDATA_KEY_SHMGET_CALL]
@@ -638,7 +656,7 @@ static void shm_send_global()
656 shm_publish_aggregated[NETDATA_KEY_SHMCTL_CALL].dimension,
657 (long long) shm_hash_values[NETDATA_KEY_SHMCTL_CALL]
658 );
641 - write_end_chart();
659 + ebpf_write_end_chart();
660 }
661
662 /**
@@ -699,42 +717,27 @@ void ebpf_shm_send_apps_data(struct ebpf_target *root)
717 {
718 struct ebpf_target *w;
719 for (w = root; w; w = w->next) {
702 - if (unlikely(w->exposed && w->processes)) {
703 - ebpf_shm_sum_pids(&w->shm, w->root_pid);
704 - }
705 - }
720 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SHM_IDX))))
721 + continue;
722
707 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SHMGET_CHART);
708 - for (w = root; w; w = w->next) {
709 - if (unlikely(w->exposed && w->processes)) {
710 - write_chart_dimension(w->name, (long long) w->shm.get);
711 - }
712 - }
713 - write_end_chart();
723 + ebpf_shm_sum_pids(&w->shm, w->root_pid);
724
715 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SHMAT_CHART);
716 - for (w = root; w; w = w->next) {
717 - if (unlikely(w->exposed && w->processes)) {
718 - write_chart_dimension(w->name, (long long) w->shm.at);
719 - }
720 - }
721 - write_end_chart();
725 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmget_call");
726 + write_chart_dimension("calls", (long long) w->shm.get);
727 + ebpf_write_end_chart();
728
723 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SHMDT_CHART);
724 - for (w = root; w; w = w->next) {
725 - if (unlikely(w->exposed && w->processes)) {
726 - write_chart_dimension(w->name, (long long) w->shm.dt);
727 - }
728 - }
729 - write_end_chart();
729 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmat_call");
730 + write_chart_dimension("calls", (long long) w->shm.at);
731 + ebpf_write_end_chart();
732
731 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SHMCTL_CHART);
732 - for (w = root; w; w = w->next) {
733 - if (unlikely(w->exposed && w->processes)) {
734 - write_chart_dimension(w->name, (long long) w->shm.ctl);
735 - }
733 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmdt_call");
734 + write_chart_dimension("calls", (long long) w->shm.dt);
735 + ebpf_write_end_chart();
736 +
737 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_shmctl_call");
738 + write_chart_dimension("calls", (long long) w->shm.ctl);
739 + ebpf_write_end_chart();
740 }
737 - write_end_chart();
741 }
742
743 /**
@@ -768,7 +771,7 @@ static void ebpf_shm_sum_cgroup_pids(netdata_publish_shm_t *shm, struct pid_on_t
771 static void ebpf_create_specific_shm_charts(char *type, int update_every)
772 {
773 ebpf_create_chart(type, NETDATA_SHMGET_CHART,
771 - "Calls to syscall <code>shmget(2)</code>.",
774 + "Calls to syscall shmget(2).",
775 EBPF_COMMON_DIMENSION_CALL,
776 NETDATA_APPS_IPC_SHM_GROUP,
777 NETDATA_CGROUP_SHM_GET_CONTEXT,
@@ -781,7 +784,7 @@ static void ebpf_create_specific_shm_charts(char *type, int update_every)
784 NETDATA_EBPF_MODULE_NAME_SHM);
785
786 ebpf_create_chart(type, NETDATA_SHMAT_CHART,
784 - "Calls to syscall <code>shmat(2)</code>.",
787 + "Calls to syscall shmat(2).",
788 EBPF_COMMON_DIMENSION_CALL,
789 NETDATA_APPS_IPC_SHM_GROUP,
790 NETDATA_CGROUP_SHM_AT_CONTEXT,
@@ -794,7 +797,7 @@ static void ebpf_create_specific_shm_charts(char *type, int update_every)
797 NETDATA_EBPF_MODULE_NAME_SHM);
798
799 ebpf_create_chart(type, NETDATA_SHMDT_CHART,
797 - "Calls to syscall <code>shmdt(2)</code>.",
800 + "Calls to syscall shmdt(2).",
801 EBPF_COMMON_DIMENSION_CALL,
802 NETDATA_APPS_IPC_SHM_GROUP,
803 NETDATA_CGROUP_SHM_DT_CONTEXT,
@@ -807,7 +810,7 @@ static void ebpf_create_specific_shm_charts(char *type, int update_every)
810 NETDATA_EBPF_MODULE_NAME_SHM);
811
812 ebpf_create_chart(type, NETDATA_SHMCTL_CHART,
810 - "Calls to syscall <code>shmctl(2)</code>.",
813 + "Calls to syscall shmctl(2).",
814 EBPF_COMMON_DIMENSION_CALL,
815 NETDATA_APPS_IPC_SHM_GROUP,
816 NETDATA_CGROUP_SHM_CTL_CONTEXT,
@@ -831,28 +834,32 @@ static void ebpf_create_specific_shm_charts(char *type, int update_every)
834 static void ebpf_obsolete_specific_shm_charts(char *type, int update_every)
835 {
836 ebpf_write_chart_obsolete(type, NETDATA_SHMGET_CHART,
834 - "Calls to syscall <code>shmget(2)</code>.",
837 + "",
838 + "Calls to syscall shmget(2).",
839 EBPF_COMMON_DIMENSION_CALL,
840 NETDATA_APPS_IPC_SHM_GROUP,
841 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_GET_CONTEXT,
842 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5800, update_every);
843
844 ebpf_write_chart_obsolete(type, NETDATA_SHMAT_CHART,
841 - "Calls to syscall <code>shmat(2)</code>.",
845 + "",
846 + "Calls to syscall shmat(2).",
847 EBPF_COMMON_DIMENSION_CALL,
848 NETDATA_APPS_IPC_SHM_GROUP,
849 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_AT_CONTEXT,
850 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5801, update_every);
851
852 ebpf_write_chart_obsolete(type, NETDATA_SHMDT_CHART,
848 - "Calls to syscall <code>shmdt(2)</code>.",
853 + "",
854 + "Calls to syscall shmdt(2).",
855 EBPF_COMMON_DIMENSION_CALL,
856 NETDATA_APPS_IPC_SHM_GROUP,
857 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_DT_CONTEXT,
858 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5802, update_every);
859
860 ebpf_write_chart_obsolete(type, NETDATA_SHMCTL_CHART,
855 - "Calls to syscall <code>shmctl(2)</code>.",
861 + "",
862 + "Calls to syscall shmctl(2).",
863 EBPF_COMMON_DIMENSION_CALL,
864 NETDATA_APPS_IPC_SHM_GROUP,
865 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SHM_CTL_CONTEXT,
@@ -869,7 +876,7 @@ static void ebpf_obsolete_specific_shm_charts(char *type, int update_every)
876 static void ebpf_create_systemd_shm_charts(int update_every)
877 {
878 ebpf_create_charts_on_systemd(NETDATA_SHMGET_CHART,
872 - "Calls to syscall <code>shmget(2)</code>.",
879 + "Calls to syscall shmget(2).",
880 EBPF_COMMON_DIMENSION_CALL,
881 NETDATA_APPS_IPC_SHM_GROUP,
882 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -878,7 +885,7 @@ static void ebpf_create_systemd_shm_charts(int update_every)
885 NETDATA_SYSTEMD_SHM_GET_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
886
887 ebpf_create_charts_on_systemd(NETDATA_SHMAT_CHART,
881 - "Calls to syscall <code>shmat(2)</code>.",
888 + "Calls to syscall shmat(2).",
889 EBPF_COMMON_DIMENSION_CALL,
890 NETDATA_APPS_IPC_SHM_GROUP,
891 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -887,7 +894,7 @@ static void ebpf_create_systemd_shm_charts(int update_every)
894 NETDATA_SYSTEMD_SHM_AT_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
895
896 ebpf_create_charts_on_systemd(NETDATA_SHMDT_CHART,
890 - "Calls to syscall <code>shmdt(2)</code>.",
897 + "Calls to syscall shmdt(2).",
898 EBPF_COMMON_DIMENSION_CALL,
899 NETDATA_APPS_IPC_SHM_GROUP,
900 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -896,7 +903,7 @@ static void ebpf_create_systemd_shm_charts(int update_every)
903 NETDATA_SYSTEMD_SHM_DT_CONTEXT, NETDATA_EBPF_MODULE_NAME_SHM, update_every);
904
905 ebpf_create_charts_on_systemd(NETDATA_SHMCTL_CHART,
899 - "Calls to syscall <code>shmctl(2)</code>.",
906 + "Calls to syscall shmctl(2).",
907 EBPF_COMMON_DIMENSION_CALL,
908 NETDATA_APPS_IPC_SHM_GROUP,
909 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -913,37 +920,37 @@ static void ebpf_create_systemd_shm_charts(int update_every)
920 static void ebpf_send_systemd_shm_charts()
921 {
922 ebpf_cgroup_target_t *ect;
916 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMGET_CHART);
923 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMGET_CHART, "");
924 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
925 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
926 write_chart_dimension(ect->name, (long long)ect->publish_shm.get);
927 }
928 }
922 - write_end_chart();
929 + ebpf_write_end_chart();
930
924 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMAT_CHART);
931 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMAT_CHART, "");
932 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
933 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
934 write_chart_dimension(ect->name, (long long)ect->publish_shm.at);
935 }
936 }
930 - write_end_chart();
937 + ebpf_write_end_chart();
938
932 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMDT_CHART);
939 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMDT_CHART, "");
940 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
941 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
942 write_chart_dimension(ect->name, (long long)ect->publish_shm.dt);
943 }
944 }
938 - write_end_chart();
945 + ebpf_write_end_chart();
946
940 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMCTL_CHART);
947 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SHMCTL_CHART, "");
948 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
949 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
950 write_chart_dimension(ect->name, (long long)ect->publish_shm.ctl);
951 }
952 }
946 - write_end_chart();
953 + ebpf_write_end_chart();
954 }
955
956 /*
@@ -956,21 +963,21 @@ static void ebpf_send_systemd_shm_charts()
963 */
964 static void ebpf_send_specific_shm_data(char *type, netdata_publish_shm_t *values)
965 {
959 - write_begin_chart(type, NETDATA_SHMGET_CHART);
966 + ebpf_write_begin_chart(type, NETDATA_SHMGET_CHART, "");
967 write_chart_dimension(shm_publish_aggregated[NETDATA_KEY_SHMGET_CALL].name, (long long)values->get);
961 - write_end_chart();
968 + ebpf_write_end_chart();
969
963 - write_begin_chart(type, NETDATA_SHMAT_CHART);
970 + ebpf_write_begin_chart(type, NETDATA_SHMAT_CHART, "");
971 write_chart_dimension(shm_publish_aggregated[NETDATA_KEY_SHMAT_CALL].name, (long long)values->at);
965 - write_end_chart();
972 + ebpf_write_end_chart();
973
967 - write_begin_chart(type, NETDATA_SHMDT_CHART);
974 + ebpf_write_begin_chart(type, NETDATA_SHMDT_CHART, "");
975 write_chart_dimension(shm_publish_aggregated[NETDATA_KEY_SHMDT_CALL].name, (long long)values->dt);
969 - write_end_chart();
976 + ebpf_write_end_chart();
977
971 - write_begin_chart(type, NETDATA_SHMCTL_CHART);
978 + ebpf_write_begin_chart(type, NETDATA_SHMCTL_CHART, "");
979 write_chart_dimension(shm_publish_aggregated[NETDATA_KEY_SHMCTL_CALL].name, (long long)values->ctl);
973 - write_end_chart();
980 + ebpf_write_end_chart();
981 }
982
983 /**
@@ -1097,41 +1104,74 @@ static void shm_collector(ebpf_module_t *em)
1104 void ebpf_shm_create_apps_charts(struct ebpf_module *em, void *ptr)
1105 {
1106 struct ebpf_target *root = ptr;
1100 - ebpf_create_charts_on_apps(NETDATA_SHMGET_CHART,
1101 - "Calls to syscall <code>shmget(2)</code>.",
1102 - EBPF_COMMON_DIMENSION_CALL,
1103 - NETDATA_APPS_IPC_SHM_GROUP,
1104 - NETDATA_EBPF_CHART_TYPE_STACKED,
1105 - 20191,
1106 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1107 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SHM);
1108 -
1109 - ebpf_create_charts_on_apps(NETDATA_SHMAT_CHART,
1110 - "Calls to syscall <code>shmat(2)</code>.",
1111 - EBPF_COMMON_DIMENSION_CALL,
1112 - NETDATA_APPS_IPC_SHM_GROUP,
1113 - NETDATA_EBPF_CHART_TYPE_STACKED,
1114 - 20192,
1115 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1116 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SHM);
1117 -
1118 - ebpf_create_charts_on_apps(NETDATA_SHMDT_CHART,
1119 - "Calls to syscall <code>shmdt(2)</code>.",
1120 - EBPF_COMMON_DIMENSION_CALL,
1121 - NETDATA_APPS_IPC_SHM_GROUP,
1122 - NETDATA_EBPF_CHART_TYPE_STACKED,
1123 - 20193,
1124 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1125 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SHM);
1126 -
1127 - ebpf_create_charts_on_apps(NETDATA_SHMCTL_CHART,
1128 - "Calls to syscall <code>shmctl(2)</code>.",
1129 - EBPF_COMMON_DIMENSION_CALL,
1130 - NETDATA_APPS_IPC_SHM_GROUP,
1131 - NETDATA_EBPF_CHART_TYPE_STACKED,
1132 - 20194,
1133 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1134 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SHM);
1107 + struct ebpf_target *w;
1108 + int update_every = em->update_every;
1109 + for (w = root; w; w = w->next) {
1110 + if (unlikely(!w->exposed))
1111 + continue;
1112 +
1113 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1114 + w->clean_name,
1115 + "_ebpf_shmget_call",
1116 + "Calls to syscall shmget(2).",
1117 + EBPF_COMMON_DIMENSION_CALL,
1118 + NETDATA_APPS_IPC_SHM_GROUP,
1119 + NETDATA_EBPF_CHART_TYPE_STACKED,
1120 + "app.ebpf_shmget_call",
1121 + 20191,
1122 + update_every,
1123 + NETDATA_EBPF_MODULE_NAME_SHM);
1124 + ebpf_create_chart_labels("app_group", w->name, 0);
1125 + ebpf_commit_label();
1126 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1127 +
1128 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1129 + w->clean_name,
1130 + "_ebpf_shmat_call",
1131 + "Calls to syscall shmat(2).",
1132 + EBPF_COMMON_DIMENSION_CALL,
1133 + NETDATA_APPS_IPC_SHM_GROUP,
1134 + NETDATA_EBPF_CHART_TYPE_STACKED,
1135 + "app.ebpf_shmat_call",
1136 + 20192,
1137 + update_every,
1138 + NETDATA_EBPF_MODULE_NAME_SHM);
1139 + ebpf_create_chart_labels("app_group", w->name, 0);
1140 + ebpf_commit_label();
1141 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1142 +
1143 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1144 + w->clean_name,
1145 + "_ebpf_shmdt_call",
1146 + "Calls to syscall shmdt(2).",
1147 + EBPF_COMMON_DIMENSION_CALL,
1148 + NETDATA_APPS_IPC_SHM_GROUP,
1149 + NETDATA_EBPF_CHART_TYPE_STACKED,
1150 + "app.ebpf_shmdt_call",
1151 + 20193,
1152 + update_every,
1153 + NETDATA_EBPF_MODULE_NAME_SHM);
1154 + ebpf_create_chart_labels("app_group", w->name, 0);
1155 + ebpf_commit_label();
1156 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1157 +
1158 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1159 + w->clean_name,
1160 + "_ebpf_shmctl_call",
1161 + "Calls to syscall shmctl(2).",
1162 + EBPF_COMMON_DIMENSION_CALL,
1163 + NETDATA_APPS_IPC_SHM_GROUP,
1164 + NETDATA_EBPF_CHART_TYPE_STACKED,
1165 + "app.ebpf_shmctl_call",
1166 + 20194,
1167 + update_every,
1168 + NETDATA_EBPF_MODULE_NAME_SHM);
1169 + ebpf_create_chart_labels("app_group", w->name, 0);
1170 + ebpf_commit_label();
1171 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1172 +
1173 + w->charts_created |= 1<<EBPF_MODULE_SHM_IDX;
1174 + }
1175
1176 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
1177 }
collectors/ebpf.plugin/ebpf_socket.c
+359 -312
@@ -515,6 +515,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
515 int order = 20080;
516 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
517 NETDATA_NET_APPS_CONNECTION_TCP_V4,
518 + "",
519 "Calls to tcp_v4_connection",
520 EBPF_COMMON_DIMENSION_CONNECTIONS,
521 NETDATA_APPS_NET_GROUP,
@@ -526,6 +527,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
527 if (tcp_v6_connect_address.type == 'T') {
528 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
529 NETDATA_NET_APPS_CONNECTION_TCP_V6,
530 + "",
531 "Calls to tcp_v6_connection",
532 EBPF_COMMON_DIMENSION_CONNECTIONS,
533 NETDATA_APPS_NET_GROUP,
@@ -537,6 +539,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
539
540 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
541 NETDATA_NET_APPS_BANDWIDTH_RECV,
542 + "",
543 "Bytes received",
544 EBPF_COMMON_DIMENSION_BITS,
545 NETDATA_APPS_NET_GROUP,
@@ -547,6 +550,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
550
551 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
552 NETDATA_NET_APPS_BANDWIDTH_SENT,
553 + "",
554 "Bytes sent",
555 EBPF_COMMON_DIMENSION_BITS,
556 NETDATA_APPS_NET_GROUP,
@@ -557,6 +561,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
561
562 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
563 NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS,
564 + "",
565 "Calls to tcp_cleanup_rbuf.",
566 EBPF_COMMON_DIMENSION_CALL,
567 NETDATA_APPS_NET_GROUP,
@@ -567,6 +572,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
572
573 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
574 NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS,
575 + "",
576 "Calls to tcp_sendmsg.",
577 EBPF_COMMON_DIMENSION_CALL,
578 NETDATA_APPS_NET_GROUP,
@@ -577,6 +583,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
583
584 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
585 NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT,
586 + "",
587 "Calls to tcp_retransmit",
588 EBPF_COMMON_DIMENSION_CALL,
589 NETDATA_APPS_NET_GROUP,
@@ -587,6 +594,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
594
595 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
596 NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS,
597 + "",
598 "Calls to udp_sendmsg",
599 EBPF_COMMON_DIMENSION_CALL,
600 NETDATA_APPS_NET_GROUP,
@@ -597,6 +605,7 @@ static void ebpf_obsolete_systemd_socket_charts(int update_every)
605
606 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
607 NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS,
608 + "",
609 "Calls to udp_recvmsg",
610 EBPF_COMMON_DIMENSION_CALL,
611 NETDATA_APPS_NET_GROUP,
@@ -639,97 +648,115 @@ static inline void ebpf_obsolete_socket_cgroup_charts(ebpf_module_t *em) {
648 void ebpf_socket_obsolete_apps_charts(struct ebpf_module *em)
649 {
650 int order = 20080;
642 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
643 - NETDATA_NET_APPS_CONNECTION_TCP_V4,
644 - "Calls to tcp_v4_connection",
645 - EBPF_COMMON_DIMENSION_CONNECTIONS,
646 - NETDATA_APPS_NET_GROUP,
647 - NETDATA_EBPF_CHART_TYPE_STACKED,
648 - NULL,
649 - order++,
650 - em->update_every);
651 + struct ebpf_target *w;
652 + int update_every = em->update_every;
653 + for (w = apps_groups_root_target; w; w = w->next) {
654 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX))))
655 + continue;
656
652 - if (tcp_v6_connect_address.type == 'T') {
653 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
654 - NETDATA_NET_APPS_CONNECTION_TCP_V6,
655 - "Calls to tcp_v6_connection",
657 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
658 + w->clean_name,
659 + "_ebpf_call_tcp_v4_connection",
660 + "Calls to tcp_v4_connection.",
661 EBPF_COMMON_DIMENSION_CONNECTIONS,
662 NETDATA_APPS_NET_GROUP,
663 NETDATA_EBPF_CHART_TYPE_STACKED,
659 - NULL,
664 + "app.ebpf_call_tcp_v4_connection",
665 order++,
661 - em->update_every);
662 - }
666 + update_every);
667
664 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
665 - NETDATA_NET_APPS_BANDWIDTH_SENT,
666 - "Bytes sent",
667 - EBPF_COMMON_DIMENSION_BITS,
668 - NETDATA_APPS_NET_GROUP,
669 - NETDATA_EBPF_CHART_TYPE_STACKED,
670 - NULL,
671 - order++,
672 - em->update_every);
668 + if (tcp_v6_connect_address.type == 'T') {
669 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
670 + w->clean_name,
671 + "_ebpf_call_tcp_v6_connection",
672 + "Calls to tcp_v6_connection.",
673 + EBPF_COMMON_DIMENSION_CONNECTIONS,
674 + NETDATA_APPS_NET_GROUP,
675 + NETDATA_EBPF_CHART_TYPE_STACKED,
676 + "app.ebpf_call_tcp_v6_connection",
677 + order++,
678 + update_every);
679 + }
680
674 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
675 - NETDATA_NET_APPS_BANDWIDTH_RECV,
676 - "bytes received",
677 - EBPF_COMMON_DIMENSION_BITS,
678 - NETDATA_APPS_NET_GROUP,
679 - NETDATA_EBPF_CHART_TYPE_STACKED,
680 - NULL,
681 - order++,
682 - em->update_every);
681 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
682 + w->clean_name,
683 + "_ebpf_sock_bytes_sent",
684 + "Bytes sent.",
685 + EBPF_COMMON_DIMENSION_BITS,
686 + NETDATA_APPS_NET_GROUP,
687 + NETDATA_EBPF_CHART_TYPE_STACKED,
688 + "app.ebpf_sock_bytes_sent",
689 + order++,
690 + update_every);
691
684 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
685 - NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS,
686 - "Calls for tcp_sendmsg",
687 - EBPF_COMMON_DIMENSION_CALL,
688 - NETDATA_APPS_NET_GROUP,
689 - NETDATA_EBPF_CHART_TYPE_STACKED,
690 - NULL,
691 - order++,
692 - em->update_every);
692 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
693 + w->clean_name,
694 + "_ebpf_sock_bytes_received",
695 + "Bytes received.",
696 + EBPF_COMMON_DIMENSION_BITS,
697 + NETDATA_APPS_NET_GROUP,
698 + NETDATA_EBPF_CHART_TYPE_STACKED,
699 + "app.ebpf_sock_bytes_received",
700 + order++,
701 + update_every);
702
694 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
695 - NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS,
696 - "Calls for tcp_cleanup_rbuf",
697 - EBPF_COMMON_DIMENSION_CALL,
698 - NETDATA_APPS_NET_GROUP,
699 - NETDATA_EBPF_CHART_TYPE_STACKED,
700 - NULL,
701 - order++,
702 - em->update_every);
703 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
704 + w->clean_name,
705 + "_ebpf_call_tcp_sendmsg",
706 + "Calls to tcp_sendmsg.",
707 + EBPF_COMMON_DIMENSION_CALL,
708 + NETDATA_APPS_NET_GROUP,
709 + NETDATA_EBPF_CHART_TYPE_STACKED,
710 + "app.ebpf_call_tcp_sendmsg",
711 + order++,
712 + update_every);
713
704 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
705 - NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT,
706 - "Calls for tcp_retransmit",
707 - EBPF_COMMON_DIMENSION_CALL,
708 - NETDATA_APPS_NET_GROUP,
709 - NETDATA_EBPF_CHART_TYPE_STACKED,
710 - NULL,
711 - order++,
712 - em->update_every);
714 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
715 + w->clean_name,
716 + "_ebpf_call_tcp_cleanup_rbuf",
717 + "Calls to tcp_cleanup_rbuf.",
718 + EBPF_COMMON_DIMENSION_CALL,
719 + NETDATA_APPS_NET_GROUP,
720 + NETDATA_EBPF_CHART_TYPE_STACKED,
721 + "app.ebpf_call_tcp_cleanup_rbuf",
722 + order++,
723 + update_every);
724
714 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
715 - NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS,
716 - "Calls for udp_sendmsg",
717 - EBPF_COMMON_DIMENSION_CALL,
718 - NETDATA_APPS_NET_GROUP,
719 - NETDATA_EBPF_CHART_TYPE_STACKED,
720 - NULL,
721 - order++,
722 - em->update_every);
725 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
726 + w->clean_name,
727 + "_ebpf_call_tcp_retransmit",
728 + "Calls to tcp_retransmit.",
729 + EBPF_COMMON_DIMENSION_CALL,
730 + NETDATA_APPS_NET_GROUP,
731 + NETDATA_EBPF_CHART_TYPE_STACKED,
732 + "app.ebpf_call_tcp_retransmit",
733 + order++,
734 + update_every);
735
724 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
725 - NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS,
726 - "Calls for udp_recvmsg",
727 - EBPF_COMMON_DIMENSION_CALL,
728 - NETDATA_APPS_NET_GROUP,
729 - NETDATA_EBPF_CHART_TYPE_STACKED,
730 - NULL,
731 - order++,
732 - em->update_every);
736 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
737 + w->clean_name,
738 + "_ebpf_call_udp_sendmsg",
739 + "Calls to udp_sendmsg.",
740 + EBPF_COMMON_DIMENSION_CALL,
741 + NETDATA_APPS_NET_GROUP,
742 + NETDATA_EBPF_CHART_TYPE_STACKED,
743 + "app.ebpf_call_udp_sendmsg",
744 + order++,
745 + update_every);
746 +
747 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
748 + w->clean_name,
749 + "_ebpf_call_udp_recvmsg",
750 + "Calls to udp_recvmsg.",
751 + EBPF_COMMON_DIMENSION_CALL,
752 + NETDATA_APPS_NET_GROUP,
753 + NETDATA_EBPF_CHART_TYPE_STACKED,
754 + "app.ebpf_call_udp_recvmsg",
755 + order++,
756 + update_every);
757 +
758 + w->charts_created &= ~(1<<EBPF_MODULE_SOCKET_IDX);
759 + }
760 }
761
762 /**
@@ -744,6 +771,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
771 int order = 21070;
772 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
773 NETDATA_INBOUND_CONNECTIONS,
774 + "",
775 "Inbound connections.",
776 EBPF_COMMON_DIMENSION_CONNECTIONS,
777 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -754,6 +782,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
782
783 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
784 NETDATA_TCP_OUTBOUND_CONNECTIONS,
785 + "",
786 "TCP outbound connections.",
787 EBPF_COMMON_DIMENSION_CONNECTIONS,
788 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -765,6 +794,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
794
795 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
796 NETDATA_TCP_FUNCTION_COUNT,
797 + "",
798 "Calls to internal functions",
799 EBPF_COMMON_DIMENSION_CALL,
800 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -775,6 +805,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
805
806 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
807 NETDATA_TCP_FUNCTION_BITS,
808 + "",
809 "TCP bandwidth",
810 EBPF_COMMON_DIMENSION_BITS,
811 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -786,6 +817,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
817 if (em->mode < MODE_ENTRY) {
818 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
819 NETDATA_TCP_FUNCTION_ERROR,
820 + "",
821 "TCP errors",
822 EBPF_COMMON_DIMENSION_CALL,
823 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -797,6 +829,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
829
830 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
831 NETDATA_TCP_RETRANSMIT,
832 + "",
833 "Packages retransmitted",
834 EBPF_COMMON_DIMENSION_CALL,
835 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -807,6 +840,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
840
841 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
842 NETDATA_UDP_FUNCTION_COUNT,
843 + "",
844 "UDP calls",
845 EBPF_COMMON_DIMENSION_CALL,
846 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -817,6 +851,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
851
852 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
853 NETDATA_UDP_FUNCTION_BITS,
854 + "",
855 "UDP bandwidth",
856 EBPF_COMMON_DIMENSION_BITS,
857 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -828,6 +863,7 @@ static void ebpf_socket_obsolete_global_charts(ebpf_module_t *em)
863 if (em->mode < MODE_ENTRY) {
864 ebpf_write_chart_obsolete(NETDATA_EBPF_IP_FAMILY,
865 NETDATA_UDP_FUNCTION_ERROR,
866 + "",
867 "UDP errors",
868 EBPF_COMMON_DIMENSION_CALL,
869 NETDATA_SOCKET_KERNEL_FUNCTIONS,
@@ -949,10 +985,10 @@ static void ebpf_socket_send_global_inbound_conn()
985 move = move->next;
986 }
987
952 - write_begin_chart(NETDATA_EBPF_IP_FAMILY, NETDATA_INBOUND_CONNECTIONS);
988 + ebpf_write_begin_chart(NETDATA_EBPF_IP_FAMILY, NETDATA_INBOUND_CONNECTIONS, "");
989 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_TCP].name, (long long) tcp_conn);
990 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_INCOMING_CONNECTION_UDP].name, (long long) udp_conn);
955 - write_end_chart();
991 + ebpf_write_end_chart();
992 }
993
994 /**
@@ -993,31 +1029,6 @@ static void ebpf_socket_send_data(ebpf_module_t *em)
1029 }
1030 }
1031
996 -/**
997 - * Sum values for pid
998 - *
999 - * @param root the structure with all available PIDs
1000 - *
1001 - * @param offset the address that we are reading
1002 - *
1003 - * @return it returns the sum of all PIDs
1004 - */
1005 -long long ebpf_socket_sum_values_for_pids(struct ebpf_pid_on_target *root, size_t offset)
1006 -{
1007 - long long ret = 0;
1008 - while (root) {
1009 - int32_t pid = root->pid;
1010 - ebpf_socket_publish_apps_t *w = socket_bandwidth_curr[pid];
1011 - if (w) {
1012 - ret += get_value_from_structure((char *)w, offset);
1013 - }
1014 -
1015 - root = root->next;
1016 - }
1017 -
1018 - return ret;
1019 -}
1020 -
1032 /**
1033 * Send data to Netdata calling auxiliary functions.
1034 *
@@ -1029,102 +1040,74 @@ void ebpf_socket_send_apps_data(ebpf_module_t *em, struct ebpf_target *root)
1040 UNUSED(em);
1041
1042 struct ebpf_target *w;
1032 - collected_number value;
1043 + // This algorithm is improved in https://github.com/netdata/netdata/pull/16030
1044 + collected_number values[9];
1045
1034 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V4);
1046 for (w = root; w; w = w->next) {
1036 - if (unlikely(w->exposed && w->processes)) {
1037 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1038 - call_tcp_v4_connection));
1039 - write_chart_dimension(w->name, value);
1040 - }
1041 - }
1042 - write_end_chart();
1047 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SOCKET_IDX))))
1048 + continue;
1049
1044 - if (tcp_v6_connect_address.type == 'T') {
1045 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V6);
1046 - for (w = root; w; w = w->next) {
1047 - if (unlikely(w->exposed && w->processes)) {
1048 - value = ebpf_socket_sum_values_for_pids(
1049 - w->root_pid, offsetof(ebpf_socket_publish_apps_t, call_tcp_v6_connection));
1050 - write_chart_dimension(w->name, value);
1050 + struct ebpf_pid_on_target *move = w->root_pid;
1051 + // Simplify algorithm, but others will appear only in https://github.com/netdata/netdata/pull/16030
1052 + memset(values, 0, sizeof(values));
1053 + while (move) {
1054 + int32_t pid = move->pid;
1055 + ebpf_socket_publish_apps_t *ws = socket_bandwidth_curr[pid];
1056 + if (ws) {
1057 + values[0] += (collected_number) ws->call_tcp_v4_connection;
1058 + values[1] += (collected_number) ws->call_tcp_v6_connection;
1059 + values[2] += (collected_number) ws->bytes_sent;
1060 + values[3] += (collected_number) ws->bytes_received;
1061 + values[4] += (collected_number) ws->call_tcp_sent;
1062 + values[5] += (collected_number) ws->call_tcp_received;
1063 + values[6] += (collected_number) ws->retransmit;
1064 + values[7] += (collected_number) ws->call_udp_sent;
1065 + values[8] += (collected_number) ws->call_udp_received;
1066 }
1052 - }
1053 - write_end_chart();
1054 - }
1067
1056 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_SENT);
1057 - for (w = root; w; w = w->next) {
1058 - if (unlikely(w->exposed && w->processes)) {
1059 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1060 - bytes_sent));
1061 - // We multiply by 0.008, because we read bytes, but we display bits
1062 - write_chart_dimension(w->name, ((value)*8)/1000);
1068 + move = move->next;
1069 }
1064 - }
1065 - write_end_chart();
1070
1067 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_RECV);
1068 - for (w = root; w; w = w->next) {
1069 - if (unlikely(w->exposed && w->processes)) {
1070 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1071 - bytes_received));
1072 - // We multiply by 0.008, because we read bytes, but we display bits
1073 - write_chart_dimension(w->name, ((value)*8)/1000);
1074 - }
1075 - }
1076 - write_end_chart();
1071 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_v4_connection");
1072 + write_chart_dimension("connections", values[0]);
1073 + ebpf_write_end_chart();
1074
1078 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS);
1079 - for (w = root; w; w = w->next) {
1080 - if (unlikely(w->exposed && w->processes)) {
1081 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1082 - call_tcp_sent));
1083 - write_chart_dimension(w->name, value);
1075 + if (tcp_v6_connect_address.type == 'T') {
1076 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_call_tcp_v6_connection");
1077 + write_chart_dimension("calls", values[1]);
1078 + ebpf_write_end_chart();
1079 }
1085 - }
1086 - write_end_chart();
1080
1088 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS);
1089 - for (w = root; w; w = w->next) {
1090 - if (unlikely(w->exposed && w->processes)) {
1091 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1092 - call_tcp_received));
1093 - write_chart_dimension(w->name, value);
1094 - }
1095 - }
1096 - write_end_chart();
1081 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_sock_bytes_sent");
1082 + // We multiply by 0.008, because we read bytes, but we display bits
1083 + write_chart_dimension("bandwidth", ((values[2])*8)/1000);
1084 + ebpf_write_end_chart();
1085
1098 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT);
1099 - for (w = root; w; w = w->next) {
1100 - if (unlikely(w->exposed && w->processes)) {
1101 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1102 - retransmit));
1103 - write_chart_dimension(w->name, value);
1104 - }
1105 - }
1106 - write_end_chart();
1086 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_sock_bytes_received");
1087 + // We multiply by 0.008, because we read bytes, but we display bits
1088 + write_chart_dimension("bandwidth", ((values[3])*8)/1000);
1089 + ebpf_write_end_chart();
1090
1108 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS);
1109 - for (w = root; w; w = w->next) {
1110 - if (unlikely(w->exposed && w->processes)) {
1111 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1112 - call_udp_sent));
1113 - write_chart_dimension(w->name, value);
1114 - }
1115 - }
1116 - write_end_chart();
1091 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_sendmsg");
1092 + write_chart_dimension("calls", values[4]);
1093 + ebpf_write_end_chart();
1094
1118 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS);
1119 - for (w = root; w; w = w->next) {
1120 - if (unlikely(w->exposed && w->processes)) {
1121 - value = ebpf_socket_sum_values_for_pids(w->root_pid, offsetof(ebpf_socket_publish_apps_t,
1122 - call_udp_received));
1123 - write_chart_dimension(w->name, value);
1124 - }
1125 - }
1126 - write_end_chart();
1095 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_cleanup_rbuf");
1096 + write_chart_dimension("calls", values[5]);
1097 + ebpf_write_end_chart();
1098 +
1099 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_tcp_retransmit");
1100 + write_chart_dimension("calls", values[6]);
1101 + ebpf_write_end_chart();
1102 +
1103 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_udp_sendmsg");
1104 + write_chart_dimension("calls", values[7]);
1105 + ebpf_write_end_chart();
1106
1107 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_udp_recvmsg");
1108 + write_chart_dimension("calls", values[8]);
1109 + ebpf_write_end_chart();
1110 + }
1111 }
1112
1113 /*****************************************************************
@@ -1266,89 +1249,152 @@ static void ebpf_socket_create_global_charts(ebpf_module_t *em)
1249 void ebpf_socket_create_apps_charts(struct ebpf_module *em, void *ptr)
1250 {
1251 struct ebpf_target *root = ptr;
1252 + struct ebpf_target *w;
1253 int order = 20080;
1270 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_CONNECTION_TCP_V4,
1271 - "Calls to tcp_v4_connection", EBPF_COMMON_DIMENSION_CONNECTIONS,
1272 - NETDATA_APPS_NET_GROUP,
1273 - NETDATA_EBPF_CHART_TYPE_STACKED,
1274 - order++,
1275 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1276 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1254 + int update_every = em->update_every;
1255 + for (w = root; w; w = w->next) {
1256 + if (unlikely(!w->exposed))
1257 + continue;
1258
1278 - if (tcp_v6_connect_address.type == 'T') {
1279 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_CONNECTION_TCP_V6,
1280 - "Calls to tcp_v6_connection",
1281 - EBPF_COMMON_DIMENSION_CONNECTIONS,
1282 - NETDATA_APPS_NET_GROUP,
1283 - NETDATA_EBPF_CHART_TYPE_STACKED,
1284 - order++,
1285 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1286 - root,
1287 - em->update_every,
1288 - NETDATA_EBPF_MODULE_NAME_SOCKET);
1289 - }
1290 -
1291 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_SENT,
1292 - "Bytes sent", EBPF_COMMON_DIMENSION_BITS,
1293 - NETDATA_APPS_NET_GROUP,
1294 - NETDATA_EBPF_CHART_TYPE_STACKED,
1295 - order++,
1296 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1297 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1298 -
1299 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_RECV,
1300 - "bytes received", EBPF_COMMON_DIMENSION_BITS,
1301 - NETDATA_APPS_NET_GROUP,
1302 - NETDATA_EBPF_CHART_TYPE_STACKED,
1303 - order++,
1304 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1305 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1306 -
1307 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS,
1308 - "Calls for tcp_sendmsg",
1309 - EBPF_COMMON_DIMENSION_CALL,
1310 - NETDATA_APPS_NET_GROUP,
1311 - NETDATA_EBPF_CHART_TYPE_STACKED,
1312 - order++,
1313 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1314 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1315 -
1316 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS,
1317 - "Calls for tcp_cleanup_rbuf",
1318 - EBPF_COMMON_DIMENSION_CALL,
1319 - NETDATA_APPS_NET_GROUP,
1320 - NETDATA_EBPF_CHART_TYPE_STACKED,
1321 - order++,
1322 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1323 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1324 -
1325 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT,
1326 - "Calls for tcp_retransmit",
1327 - EBPF_COMMON_DIMENSION_CALL,
1328 - NETDATA_APPS_NET_GROUP,
1329 - NETDATA_EBPF_CHART_TYPE_STACKED,
1330 - order++,
1331 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1332 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1333 -
1334 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS,
1335 - "Calls for udp_sendmsg",
1336 - EBPF_COMMON_DIMENSION_CALL,
1337 - NETDATA_APPS_NET_GROUP,
1338 - NETDATA_EBPF_CHART_TYPE_STACKED,
1339 - order++,
1340 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1341 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1342 -
1343 - ebpf_create_charts_on_apps(NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS,
1344 - "Calls for udp_recvmsg",
1345 - EBPF_COMMON_DIMENSION_CALL,
1346 - NETDATA_APPS_NET_GROUP,
1347 - NETDATA_EBPF_CHART_TYPE_STACKED,
1348 - order++,
1349 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
1350 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SOCKET);
1259 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1260 + w->clean_name,
1261 + "_ebpf_call_tcp_v4_connection",
1262 + "Calls to tcp_v4_connection.",
1263 + EBPF_COMMON_DIMENSION_CONNECTIONS,
1264 + NETDATA_APPS_NET_GROUP,
1265 + NETDATA_EBPF_CHART_TYPE_STACKED,
1266 + "app.ebpf_call_tcp_v4_connection",
1267 + order++,
1268 + update_every,
1269 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1270 + ebpf_create_chart_labels("app_group", w->name, 0);
1271 + ebpf_commit_label();
1272 + fprintf(stdout, "DIMENSION connections '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1273
1274 + if (tcp_v6_connect_address.type == 'T') {
1275 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1276 + w->clean_name,
1277 + "_ebpf_call_tcp_v6_connection",
1278 + "Calls to tcp_v6_connection.",
1279 + EBPF_COMMON_DIMENSION_CONNECTIONS,
1280 + NETDATA_APPS_NET_GROUP,
1281 + NETDATA_EBPF_CHART_TYPE_STACKED,
1282 + "app.ebpf_call_tcp_v6_connection",
1283 + order++,
1284 + update_every,
1285 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1286 + ebpf_create_chart_labels("app_group", w->name, 0);
1287 + ebpf_commit_label();
1288 + fprintf(stdout, "DIMENSION connections '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1289 + }
1290 +
1291 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1292 + w->clean_name,
1293 + "_ebpf_sock_bytes_sent",
1294 + "Bytes sent.",
1295 + EBPF_COMMON_DIMENSION_BITS,
1296 + NETDATA_APPS_NET_GROUP,
1297 + NETDATA_EBPF_CHART_TYPE_STACKED,
1298 + "app.ebpf_sock_bytes_sent",
1299 + order++,
1300 + update_every,
1301 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1302 + ebpf_create_chart_labels("app_group", w->name, 0);
1303 + ebpf_commit_label();
1304 + fprintf(stdout, "DIMENSION bandwidth '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1305 +
1306 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1307 + w->clean_name,
1308 + "_ebpf_sock_bytes_received",
1309 + "Bytes received.",
1310 + EBPF_COMMON_DIMENSION_BITS,
1311 + NETDATA_APPS_NET_GROUP,
1312 + NETDATA_EBPF_CHART_TYPE_STACKED,
1313 + "app.ebpf_sock_bytes_received",
1314 + order++,
1315 + update_every,
1316 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1317 + ebpf_create_chart_labels("app_group", w->name, 0);
1318 + ebpf_commit_label();
1319 + fprintf(stdout, "DIMENSION bandwidth '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1320 +
1321 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1322 + w->clean_name,
1323 + "_ebpf_call_tcp_sendmsg",
1324 + "Calls to tcp_sendmsg.",
1325 + EBPF_COMMON_DIMENSION_CALL,
1326 + NETDATA_APPS_NET_GROUP,
1327 + NETDATA_EBPF_CHART_TYPE_STACKED,
1328 + "app.ebpf_call_tcp_sendmsg",
1329 + order++,
1330 + update_every,
1331 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1332 + ebpf_create_chart_labels("app_group", w->name, 0);
1333 + ebpf_commit_label();
1334 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1335 +
1336 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1337 + w->clean_name,
1338 + "_ebpf_call_tcp_cleanup_rbuf",
1339 + "Calls to tcp_cleanup_rbuf.",
1340 + EBPF_COMMON_DIMENSION_CALL,
1341 + NETDATA_APPS_NET_GROUP,
1342 + NETDATA_EBPF_CHART_TYPE_STACKED,
1343 + "app.ebpf_call_tcp_cleanup_rbuf",
1344 + order++,
1345 + update_every,
1346 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1347 + ebpf_create_chart_labels("app_group", w->name, 0);
1348 + ebpf_commit_label();
1349 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1350 +
1351 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1352 + w->clean_name,
1353 + "_ebpf_call_tcp_retransmit",
1354 + "Calls to tcp_retransmit.",
1355 + EBPF_COMMON_DIMENSION_CALL,
1356 + NETDATA_APPS_NET_GROUP,
1357 + NETDATA_EBPF_CHART_TYPE_STACKED,
1358 + "app.ebpf_call_tcp_retransmit",
1359 + order++,
1360 + update_every,
1361 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1362 + ebpf_create_chart_labels("app_group", w->name, 0);
1363 + ebpf_commit_label();
1364 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1365 +
1366 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1367 + w->clean_name,
1368 + "_ebpf_call_udp_sendmsg",
1369 + "Calls to udp_sendmsg.",
1370 + EBPF_COMMON_DIMENSION_CALL,
1371 + NETDATA_APPS_NET_GROUP,
1372 + NETDATA_EBPF_CHART_TYPE_STACKED,
1373 + "app.ebpf_call_udp_sendmsg",
1374 + order++,
1375 + update_every,
1376 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1377 + ebpf_create_chart_labels("app_group", w->name, 0);
1378 + ebpf_commit_label();
1379 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1380 +
1381 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
1382 + w->clean_name,
1383 + "_ebpf_call_udp_recvmsg",
1384 + "Calls to udp_recvmsg.",
1385 + EBPF_COMMON_DIMENSION_CALL,
1386 + NETDATA_APPS_NET_GROUP,
1387 + NETDATA_EBPF_CHART_TYPE_STACKED,
1388 + "app.ebpf_call_udp_recvmsg",
1389 + order,
1390 + update_every,
1391 + NETDATA_EBPF_MODULE_NAME_SOCKET);
1392 + ebpf_create_chart_labels("app_group", w->name, 0);
1393 + ebpf_commit_label();
1394 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
1395 +
1396 + w->charts_created |= 1<<EBPF_MODULE_SOCKET_IDX;
1397 + }
1398 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
1399 }
1400
@@ -2162,7 +2208,7 @@ static void ebpf_create_specific_socket_charts(char *type, int update_every)
2208 static void ebpf_obsolete_specific_socket_charts(char *type, int update_every)
2209 {
2210 int order_basis = 5300;
2165 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_CONNECTION_TCP_V4, "Calls to tcp_v4_connection",
2211 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_CONNECTION_TCP_V4, "", "Calls to tcp_v4_connection",
2212 EBPF_COMMON_DIMENSION_CONNECTIONS, NETDATA_APPS_NET_GROUP,
2213 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_TCP_V4_CONN_CONTEXT,
2214 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
@@ -2170,6 +2216,7 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every)
2216 if (tcp_v6_connect_address.type == 'T') {
2217 ebpf_write_chart_obsolete(type,
2218 NETDATA_NET_APPS_CONNECTION_TCP_V6,
2219 + "",
2220 "Calls to tcp_v6_connection",
2221 EBPF_COMMON_DIMENSION_CONNECTIONS,
2222 NETDATA_APPS_NET_GROUP,
@@ -2179,37 +2226,37 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every)
2226 update_every);
2227 }
2228
2182 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_RECV, "Bytes received",
2229 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_RECV, "", "Bytes received",
2230 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP,
2231 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_BYTES_RECV_CONTEXT,
2232 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
2233
2187 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_SENT,"Bytes sent",
2234 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_SENT, "","Bytes sent",
2235 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP,
2236 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_BYTES_SEND_CONTEXT,
2237 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
2238
2192 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, "Calls to tcp_cleanup_rbuf.",
2239 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, "", "Calls to tcp_cleanup_rbuf.",
2240 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP,
2241 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_TCP_RECV_CONTEXT,
2242 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
2243
2197 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, "Calls to tcp_sendmsg.",
2244 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, "", "Calls to tcp_sendmsg.",
2245 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP,
2246 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_TCP_SEND_CONTEXT,
2247 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
2248
2202 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, "Calls to tcp_retransmit.",
2249 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, "", "Calls to tcp_retransmit.",
2250 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP,
2251 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_TCP_RETRANSMIT_CONTEXT,
2252 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
2253
2207 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, "Calls to udp_sendmsg",
2254 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, "", "Calls to udp_sendmsg",
2255 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP,
2256 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_SERVICES_SOCKET_UDP_SEND_CONTEXT,
2257 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
2258
2212 - ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, "Calls to udp_recvmsg",
2259 + ebpf_write_chart_obsolete(type, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, "", "Calls to udp_recvmsg",
2260 EBPF_COMMON_DIMENSION_CALL, NETDATA_APPS_NET_GROUP, NETDATA_EBPF_CHART_TYPE_LINE,
2261 NETDATA_SERVICES_SOCKET_UDP_RECV_CONTEXT,
2262 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + order_basis++, update_every);
@@ -2225,52 +2272,52 @@ static void ebpf_obsolete_specific_socket_charts(char *type, int update_every)
2272 */
2273 static void ebpf_send_specific_socket_data(char *type, ebpf_socket_publish_apps_t *values)
2274 {
2228 - write_begin_chart(type, NETDATA_NET_APPS_CONNECTION_TCP_V4);
2275 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_CONNECTION_TCP_V4, "");
2276 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_TCP_CONNECTION_V4].name,
2277 (long long) values->call_tcp_v4_connection);
2231 - write_end_chart();
2278 + ebpf_write_end_chart();
2279
2280 if (tcp_v6_connect_address.type == 'T') {
2234 - write_begin_chart(type, NETDATA_NET_APPS_CONNECTION_TCP_V6);
2281 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_CONNECTION_TCP_V6, "");
2282 write_chart_dimension(
2283 socket_publish_aggregated[NETDATA_IDX_TCP_CONNECTION_V6].name, (long long)values->call_tcp_v6_connection);
2237 - write_end_chart();
2284 + ebpf_write_end_chart();
2285 }
2286
2240 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_SENT);
2287 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_SENT, "");
2288 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_TCP_SENDMSG].name,
2289 (long long) values->bytes_sent);
2243 - write_end_chart();
2290 + ebpf_write_end_chart();
2291
2245 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_RECV);
2292 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_RECV, "");
2293 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_TCP_CLEANUP_RBUF].name,
2294 (long long) values->bytes_received);
2248 - write_end_chart();
2295 + ebpf_write_end_chart();
2296
2250 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS);
2297 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, "");
2298 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_TCP_SENDMSG].name,
2299 (long long) values->call_tcp_sent);
2253 - write_end_chart();
2300 + ebpf_write_end_chart();
2301
2255 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS);
2302 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, "");
2303 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_TCP_CLEANUP_RBUF].name,
2304 (long long) values->call_tcp_received);
2258 - write_end_chart();
2305 + ebpf_write_end_chart();
2306
2260 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT);
2307 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, "");
2308 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_TCP_RETRANSMIT].name,
2309 (long long) values->retransmit);
2263 - write_end_chart();
2310 + ebpf_write_end_chart();
2311
2265 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS);
2312 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, "");
2313 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_UDP_SENDMSG].name,
2314 (long long) values->call_udp_sent);
2268 - write_end_chart();
2315 + ebpf_write_end_chart();
2316
2270 - write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS);
2317 + ebpf_write_begin_chart(type, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, "");
2318 write_chart_dimension(socket_publish_aggregated[NETDATA_IDX_UDP_RECVBUF].name,
2319 (long long) values->call_udp_received);
2273 - write_end_chart();
2320 + ebpf_write_end_chart();
2321 }
2322
2323 /**
@@ -2382,79 +2429,79 @@ static void ebpf_create_systemd_socket_charts(int update_every)
2429 static void ebpf_send_systemd_socket_charts()
2430 {
2431 ebpf_cgroup_target_t *ect;
2385 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V4);
2432 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V4, "");
2433 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2434 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2435 write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_v4_connection);
2436 }
2437 }
2391 - write_end_chart();
2438 + ebpf_write_end_chart();
2439
2440 if (tcp_v6_connect_address.type == 'T') {
2394 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V6);
2441 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_CONNECTION_TCP_V6, "");
2442 for (ect = ebpf_cgroup_pids; ect; ect = ect->next) {
2443 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2444 write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_v6_connection);
2445 }
2446 }
2400 - write_end_chart();
2447 + ebpf_write_end_chart();
2448 }
2449
2403 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_SENT);
2450 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_SENT, "");
2451 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2452 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2453 write_chart_dimension(ect->name, (long long)ect->publish_socket.bytes_sent);
2454 }
2455 }
2409 - write_end_chart();
2456 + ebpf_write_end_chart();
2457
2411 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_RECV);
2458 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_RECV, "");
2459 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2460 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2461 write_chart_dimension(ect->name, (long long)ect->publish_socket.bytes_received);
2462 }
2463 }
2417 - write_end_chart();
2464 + ebpf_write_end_chart();
2465
2419 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS);
2466 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_SEND_CALLS, "");
2467 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2468 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2469 write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_sent);
2470 }
2471 }
2425 - write_end_chart();
2472 + ebpf_write_end_chart();
2473
2427 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS);
2474 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RECV_CALLS, "");
2475 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2476 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2477 write_chart_dimension(ect->name, (long long)ect->publish_socket.call_tcp_received);
2478 }
2479 }
2433 - write_end_chart();
2480 + ebpf_write_end_chart();
2481
2435 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT);
2482 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_TCP_RETRANSMIT, "");
2483 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2484 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2485 write_chart_dimension(ect->name, (long long)ect->publish_socket.retransmit);
2486 }
2487 }
2441 - write_end_chart();
2488 + ebpf_write_end_chart();
2489
2443 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS);
2490 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_SEND_CALLS, "");
2491 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2492 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2493 write_chart_dimension(ect->name, (long long)ect->publish_socket.call_udp_sent);
2494 }
2495 }
2449 - write_end_chart();
2496 + ebpf_write_end_chart();
2497
2451 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS);
2498 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_NET_APPS_BANDWIDTH_UDP_RECV_CALLS, "");
2499 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
2500 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
2501 write_chart_dimension(ect->name, (long long)ect->publish_socket.call_udp_received);
2502 }
2503 }
2457 - write_end_chart();
2504 + ebpf_write_end_chart();
2505 }
2506
2507 /**
collectors/ebpf.plugin/ebpf_socket.h
-4
@@ -318,10 +318,6 @@ typedef struct netata_socket_plus {
318 } socket_string;
319 } netdata_socket_plus_t;
320
321 -enum netdata_udp_ports {
322 - NETDATA_EBPF_UDP_PORT = 53
323 -};
324 -
321 extern ARAL *aral_socket_table;
322
323 /**
collectors/ebpf.plugin/ebpf_softirq.c
+3 -2
@@ -71,6 +71,7 @@ static void ebpf_obsolete_softirq_global(ebpf_module_t *em)
71 {
72 ebpf_write_chart_obsolete(NETDATA_EBPF_SYSTEM_GROUP,
73 "softirq_latency",
74 + "",
75 "Software IRQ latency",
76 EBPF_COMMON_DIMENSION_MILLISECONDS,
77 "softirqs",
@@ -228,9 +229,9 @@ static void softirq_collector(ebpf_module_t *em)
229 pthread_mutex_lock(&lock);
230
231 // write dims now for all hitherto discovered IRQs.
231 - write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, "softirq_latency");
232 + ebpf_write_begin_chart(NETDATA_EBPF_SYSTEM_GROUP, "softirq_latency", "");
233 softirq_write_dims();
233 - write_end_chart();
234 + ebpf_write_end_chart();
235
236 pthread_mutex_unlock(&lock);
237
collectors/ebpf.plugin/ebpf_swap.c
+95 -68
@@ -234,7 +234,8 @@ static void ebpf_obsolete_swap_services(ebpf_module_t *em)
234 {
235 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
236 NETDATA_MEM_SWAP_READ_CHART,
237 - "Calls to function <code>swap_readpage</code>.",
237 + "",
238 + "Calls to function swap_readpage.",
239 EBPF_COMMON_DIMENSION_CALL,
240 NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
241 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -244,7 +245,8 @@ static void ebpf_obsolete_swap_services(ebpf_module_t *em)
245
246 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
247 NETDATA_MEM_SWAP_WRITE_CHART,
247 - "Calls to function <code>swap_writepage</code>.",
248 + "",
249 + "Calls to function swap_writepage.",
250 EBPF_COMMON_DIMENSION_CALL,
251 NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
252 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -284,25 +286,35 @@ static inline void ebpf_obsolete_swap_cgroup_charts(ebpf_module_t *em) {
286 */
287 void ebpf_obsolete_swap_apps_charts(struct ebpf_module *em)
288 {
287 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
288 - NETDATA_MEM_SWAP_READ_CHART,
289 - "Calls to function <code>swap_readpage</code>.",
290 - EBPF_COMMON_DIMENSION_CALL,
291 - NETDATA_SWAP_SUBMENU,
292 - NETDATA_EBPF_CHART_TYPE_STACKED,
293 - NULL,
294 - 20191,
295 - em->update_every);
289 + struct ebpf_target *w;
290 + int update_every = em->update_every;
291 + for (w = apps_groups_root_target; w; w = w->next) {
292 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SWAP_IDX))))
293 + continue;
294
297 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
298 - NETDATA_MEM_SWAP_WRITE_CHART,
299 - "Calls to function <code>swap_writepage</code>.",
300 - EBPF_COMMON_DIMENSION_CALL,
301 - NETDATA_SWAP_SUBMENU,
302 - NETDATA_EBPF_CHART_TYPE_STACKED,
303 - NULL,
304 - 20192,
305 - em->update_every);
295 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
296 + w->clean_name,
297 + "_ebpf_call_swap_readpage",
298 + "Calls to function swap_readpage.",
299 + EBPF_COMMON_DIMENSION_CALL,
300 + NETDATA_EBPF_MEMORY_GROUP,
301 + NETDATA_EBPF_CHART_TYPE_STACKED,
302 + "app.ebpf_call_swap_readpage",
303 + 20070,
304 + update_every);
305 +
306 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
307 + w->clean_name,
308 + "_ebpf_call_swap_writepage",
309 + "Calls to function swap_writepage.",
310 + EBPF_COMMON_DIMENSION_CALL,
311 + NETDATA_EBPF_MEMORY_GROUP,
312 + NETDATA_EBPF_CHART_TYPE_STACKED,
313 + "app.ebpf_call_swap_writepage",
314 + 20071,
315 + update_every);
316 + w->charts_created &= ~(1<<EBPF_MODULE_SWAP_IDX);
317 + }
318 }
319
320 /**
@@ -316,6 +328,7 @@ static void ebpf_obsolete_swap_global(ebpf_module_t *em)
328 {
329 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
330 NETDATA_MEM_SWAP_CHART,
331 + "",
332 "Calls to access swap memory",
333 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_SWAP_SUBMENU,
334 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -568,26 +581,19 @@ void ebpf_swap_send_apps_data(struct ebpf_target *root)
581 {
582 struct ebpf_target *w;
583 for (w = root; w; w = w->next) {
571 - if (unlikely(w->exposed && w->processes)) {
572 - ebpf_swap_sum_pids(&w->swap, w->root_pid);
573 - }
574 - }
584 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_SWAP_IDX))))
585 + continue;
586
576 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_MEM_SWAP_READ_CHART);
577 - for (w = root; w; w = w->next) {
578 - if (unlikely(w->exposed && w->processes)) {
579 - write_chart_dimension(w->name, (long long) w->swap.read);
580 - }
581 - }
582 - write_end_chart();
587 + ebpf_swap_sum_pids(&w->swap, w->root_pid);
588
584 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_MEM_SWAP_WRITE_CHART);
585 - for (w = root; w; w = w->next) {
586 - if (unlikely(w->exposed && w->processes)) {
587 - write_chart_dimension(w->name, (long long) w->swap.write);
588 - }
589 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_swap_readpage");
590 + write_chart_dimension("calls", (long long) w->swap.read);
591 + ebpf_write_end_chart();
592 +
593 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_swap_writepage");
594 + write_chart_dimension("calls", (long long) w->swap.write);
595 + ebpf_write_end_chart();
596 }
590 - write_end_chart();
597 }
598
599 /**
@@ -624,21 +630,21 @@ static void ebpf_swap_sum_cgroup_pids(netdata_publish_swap_t *swap, struct pid_o
630 static void ebpf_send_systemd_swap_charts()
631 {
632 ebpf_cgroup_target_t *ect;
627 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_MEM_SWAP_READ_CHART);
633 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_MEM_SWAP_READ_CHART, "");
634 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
635 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
636 write_chart_dimension(ect->name, (long long) ect->publish_systemd_swap.read);
637 }
638 }
633 - write_end_chart();
639 + ebpf_write_end_chart();
640
635 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_MEM_SWAP_WRITE_CHART);
641 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_MEM_SWAP_WRITE_CHART, "");
642 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
643 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
644 write_chart_dimension(ect->name, (long long) ect->publish_systemd_swap.write);
645 }
646 }
641 - write_end_chart();
647 + ebpf_write_end_chart();
648 }
649
650 /**
@@ -652,7 +658,7 @@ static void ebpf_send_systemd_swap_charts()
658 static void ebpf_create_specific_swap_charts(char *type, int update_every)
659 {
660 ebpf_create_chart(type, NETDATA_MEM_SWAP_READ_CHART,
655 - "Calls to function <code>swap_readpage</code>.",
661 + "Calls to function swap_readpage.",
662 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
663 NETDATA_CGROUP_SWAP_READ_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
664 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100,
@@ -660,7 +666,7 @@ static void ebpf_create_specific_swap_charts(char *type, int update_every)
666 swap_publish_aggregated, 1, update_every, NETDATA_EBPF_MODULE_NAME_SWAP);
667
668 ebpf_create_chart(type, NETDATA_MEM_SWAP_WRITE_CHART,
663 - "Calls to function <code>swap_writepage</code>.",
669 + "Calls to function swap_writepage.",
670 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
671 NETDATA_CGROUP_SWAP_WRITE_CONTEXT, NETDATA_EBPF_CHART_TYPE_LINE,
672 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101,
@@ -679,12 +685,12 @@ static void ebpf_create_specific_swap_charts(char *type, int update_every)
685 */
686 static void ebpf_obsolete_specific_swap_charts(char *type, int update_every)
687 {
682 - ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_READ_CHART,"Calls to function <code>swap_readpage</code>.",
688 + ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_READ_CHART, "", "Calls to function swap_readpage.",
689 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
690 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SWAP_READ_CONTEXT,
691 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5100, update_every);
692
687 - ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_WRITE_CHART, "Calls to function <code>swap_writepage</code>.",
693 + ebpf_write_chart_obsolete(type, NETDATA_MEM_SWAP_WRITE_CHART, "", "Calls to function swap_writepage.",
694 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
695 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_SWAP_WRITE_CONTEXT,
696 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5101, update_every);
@@ -700,13 +706,13 @@ static void ebpf_obsolete_specific_swap_charts(char *type, int update_every)
706 */
707 static void ebpf_send_specific_swap_data(char *type, netdata_publish_swap_t *values)
708 {
703 - write_begin_chart(type, NETDATA_MEM_SWAP_READ_CHART);
709 + ebpf_write_begin_chart(type, NETDATA_MEM_SWAP_READ_CHART, "");
710 write_chart_dimension(swap_publish_aggregated[NETDATA_KEY_SWAP_READPAGE_CALL].name, (long long) values->read);
705 - write_end_chart();
711 + ebpf_write_end_chart();
712
707 - write_begin_chart(type, NETDATA_MEM_SWAP_WRITE_CHART);
713 + ebpf_write_begin_chart(type, NETDATA_MEM_SWAP_WRITE_CHART, "");
714 write_chart_dimension(swap_publish_aggregated[NETDATA_KEY_SWAP_WRITEPAGE_CALL].name, (long long) values->write);
709 - write_end_chart();
715 + ebpf_write_end_chart();
716 }
717
718 /**
@@ -719,14 +725,14 @@ static void ebpf_send_specific_swap_data(char *type, netdata_publish_swap_t *val
725 static void ebpf_create_systemd_swap_charts(int update_every)
726 {
727 ebpf_create_charts_on_systemd(NETDATA_MEM_SWAP_READ_CHART,
722 - "Calls to <code>swap_readpage</code>.",
728 + "Calls to swap_readpage.",
729 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
730 NETDATA_EBPF_CHART_TYPE_STACKED, 20191,
731 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_SWAP_READ_CONTEXT,
732 NETDATA_EBPF_MODULE_NAME_SWAP, update_every);
733
734 ebpf_create_charts_on_systemd(NETDATA_MEM_SWAP_WRITE_CHART,
729 - "Calls to function <code>swap_writepage</code>.",
735 + "Calls to function swap_writepage.",
736 EBPF_COMMON_DIMENSION_CALL, NETDATA_SYSTEM_CGROUP_SWAP_SUBMENU,
737 NETDATA_EBPF_CHART_TYPE_STACKED, 20192,
738 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_SWAP_WRITE_CONTEXT,
@@ -851,23 +857,44 @@ static void swap_collector(ebpf_module_t *em)
857 void ebpf_swap_create_apps_charts(struct ebpf_module *em, void *ptr)
858 {
859 struct ebpf_target *root = ptr;
854 - ebpf_create_charts_on_apps(NETDATA_MEM_SWAP_READ_CHART,
855 - "Calls to function <code>swap_readpage</code>.",
856 - EBPF_COMMON_DIMENSION_CALL,
857 - NETDATA_SWAP_SUBMENU,
858 - NETDATA_EBPF_CHART_TYPE_STACKED,
859 - 20191,
860 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
861 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SWAP);
862 -
863 - ebpf_create_charts_on_apps(NETDATA_MEM_SWAP_WRITE_CHART,
864 - "Calls to function <code>swap_writepage</code>.",
865 - EBPF_COMMON_DIMENSION_CALL,
866 - NETDATA_SWAP_SUBMENU,
867 - NETDATA_EBPF_CHART_TYPE_STACKED,
868 - 20192,
869 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
870 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_SWAP);
860 + struct ebpf_target *w;
861 + int update_every = em->update_every;
862 + for (w = root; w; w = w->next) {
863 + if (unlikely(!w->exposed))
864 + continue;
865 +
866 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
867 + w->clean_name,
868 + "_ebpf_call_swap_readpage",
869 + "Calls to function swap_readpage.",
870 + EBPF_COMMON_DIMENSION_CALL,
871 + NETDATA_EBPF_MEMORY_GROUP,
872 + NETDATA_EBPF_CHART_TYPE_STACKED,
873 + "app.ebpf_call_swap_readpage",
874 + 20070,
875 + update_every,
876 + NETDATA_EBPF_MODULE_NAME_SWAP);
877 + ebpf_create_chart_labels("app_group", w->name, 0);
878 + ebpf_commit_label();
879 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
880 +
881 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
882 + w->clean_name,
883 + "_ebpf_call_swap_writepage",
884 + "Calls to function swap_writepage.",
885 + EBPF_COMMON_DIMENSION_CALL,
886 + NETDATA_EBPF_MEMORY_GROUP,
887 + NETDATA_EBPF_CHART_TYPE_STACKED,
888 + "app.ebpf_call_swap_writepage",
889 + 20071,
890 + update_every,
891 + NETDATA_EBPF_MODULE_NAME_SWAP);
892 + ebpf_create_chart_labels("app_group", w->name, 0);
893 + ebpf_commit_label();
894 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
895 +
896 + w->charts_created |= 1<<EBPF_MODULE_SWAP_IDX;
897 + }
898 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
899 }
900
collectors/ebpf.plugin/ebpf_sync.c
+15 -11
@@ -298,7 +298,8 @@ static void ebpf_obsolete_sync_global(ebpf_module_t *em)
298 if (local_syscalls[NETDATA_SYNC_FSYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_FDATASYNC_IDX].enabled)
299 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
300 NETDATA_EBPF_FILE_SYNC_CHART,
301 - "Monitor calls for <code>fsync(2)</code> and <code>fdatasync(2)</code>.",
301 + "",
302 + "Monitor calls to fsync(2) and fdatasync(2).",
303 EBPF_COMMON_DIMENSION_CALL,
304 NETDATA_EBPF_SYNC_SUBMENU,
305 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -309,7 +310,8 @@ static void ebpf_obsolete_sync_global(ebpf_module_t *em)
310 if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)
311 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
312 NETDATA_EBPF_MSYNC_CHART,
312 - "Monitor calls for <code>msync(2)</code>.",
313 + "",
314 + "Monitor calls to msync(2).",
315 EBPF_COMMON_DIMENSION_CALL,
316 NETDATA_EBPF_SYNC_SUBMENU,
317 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -320,7 +322,8 @@ static void ebpf_obsolete_sync_global(ebpf_module_t *em)
322 if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled)
323 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
324 NETDATA_EBPF_SYNC_CHART,
323 - "Monitor calls for <code>sync(2)</code> and <code>syncfs(2)</code>.",
325 + "",
326 + "Monitor calls to sync(2) and syncfs(2).",
327 EBPF_COMMON_DIMENSION_CALL,
328 NETDATA_EBPF_SYNC_SUBMENU,
329 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -331,7 +334,8 @@ static void ebpf_obsolete_sync_global(ebpf_module_t *em)
334 if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)
335 ebpf_write_chart_obsolete(NETDATA_EBPF_MEMORY_GROUP,
336 NETDATA_EBPF_FILE_SEGMENT_CHART,
334 - "Monitor calls for <code>sync_file_range(2)</code>.",
337 + "",
338 + "Monitor calls to sync_file_range(2).",
339 EBPF_COMMON_DIMENSION_CALL,
340 NETDATA_EBPF_SYNC_SUBMENU,
341 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -507,7 +511,7 @@ static void ebpf_send_sync_chart(char *id,
511 int idx,
512 int end)
513 {
510 - write_begin_chart(NETDATA_EBPF_MEMORY_GROUP, id);
514 + ebpf_write_begin_chart(NETDATA_EBPF_MEMORY_GROUP, id, "");
515
516 netdata_publish_syscall_t *move = &sync_counter_publish_aggregated[idx];
517
@@ -519,7 +523,7 @@ static void ebpf_send_sync_chart(char *id,
523 idx++;
524 }
525
522 - write_end_chart();
526 + ebpf_write_end_chart();
527 }
528
529 /**
@@ -610,7 +614,7 @@ static void ebpf_create_sync_chart(char *id,
614 int end,
615 int update_every)
616 {
613 - ebpf_write_chart_cmd(NETDATA_EBPF_MEMORY_GROUP, id, title, EBPF_COMMON_DIMENSION_CALL,
617 + ebpf_write_chart_cmd(NETDATA_EBPF_MEMORY_GROUP, id, "", title, EBPF_COMMON_DIMENSION_CALL,
618 NETDATA_EBPF_SYNC_SUBMENU, NETDATA_EBPF_CHART_TYPE_LINE, NULL, order,
619 update_every,
620 NETDATA_EBPF_MODULE_NAME_SYNC);
@@ -637,22 +641,22 @@ static void ebpf_create_sync_charts(int update_every)
641 {
642 if (local_syscalls[NETDATA_SYNC_FSYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_FDATASYNC_IDX].enabled)
643 ebpf_create_sync_chart(NETDATA_EBPF_FILE_SYNC_CHART,
640 - "Monitor calls for <code>fsync(2)</code> and <code>fdatasync(2)</code>.", 21300,
644 + "Monitor calls to fsync(2) and fdatasync(2).", 21300,
645 NETDATA_SYNC_FSYNC_IDX, NETDATA_SYNC_FDATASYNC_IDX, update_every);
646
647 if (local_syscalls[NETDATA_SYNC_MSYNC_IDX].enabled)
648 ebpf_create_sync_chart(NETDATA_EBPF_MSYNC_CHART,
645 - "Monitor calls for <code>msync(2)</code>.", 21301,
649 + "Monitor calls to msync(2).", 21301,
650 NETDATA_SYNC_MSYNC_IDX, NETDATA_SYNC_MSYNC_IDX, update_every);
651
652 if (local_syscalls[NETDATA_SYNC_SYNC_IDX].enabled && local_syscalls[NETDATA_SYNC_SYNCFS_IDX].enabled)
653 ebpf_create_sync_chart(NETDATA_EBPF_SYNC_CHART,
650 - "Monitor calls for <code>sync(2)</code> and <code>syncfs(2)</code>.", 21302,
654 + "Monitor calls to sync(2) and syncfs(2).", 21302,
655 NETDATA_SYNC_SYNC_IDX, NETDATA_SYNC_SYNCFS_IDX, update_every);
656
657 if (local_syscalls[NETDATA_SYNC_SYNC_FILE_RANGE_IDX].enabled)
658 ebpf_create_sync_chart(NETDATA_EBPF_FILE_SEGMENT_CHART,
655 - "Monitor calls for <code>sync_file_range(2)</code>.", 21303,
659 + "Monitor calls to sync_file_range(2).", 21303,
660 NETDATA_SYNC_SYNC_FILE_RANGE_IDX, NETDATA_SYNC_SYNC_FILE_RANGE_IDX, update_every);
661
662 fflush(stdout);
collectors/ebpf.plugin/ebpf_vfs.c
+498 -413
@@ -420,6 +420,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
420 {
421 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
422 NETDATA_SYSCALL_APPS_FILE_DELETED,
423 + "",
424 "Files deleted",
425 EBPF_COMMON_DIMENSION_CALL,
426 NETDATA_VFS_CGROUP_GROUP,
@@ -430,6 +431,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
431
432 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
433 NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,
434 + "",
435 "Write to disk",
436 EBPF_COMMON_DIMENSION_CALL,
437 NETDATA_VFS_CGROUP_GROUP,
@@ -441,6 +443,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
443 if (em->mode < MODE_ENTRY) {
444 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
445 NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,
446 + "",
447 "Fails to write",
448 EBPF_COMMON_DIMENSION_CALL,
449 NETDATA_VFS_CGROUP_GROUP,
@@ -452,6 +455,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
455
456 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
457 NETDATA_SYSCALL_APPS_VFS_READ_CALLS,
458 + "",
459 "Read from disk",
460 EBPF_COMMON_DIMENSION_CALL,
461 NETDATA_VFS_CGROUP_GROUP,
@@ -463,6 +467,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
467 if (em->mode < MODE_ENTRY) {
468 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
469 NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,
470 + "",
471 "Fails to read",
472 EBPF_COMMON_DIMENSION_CALL,
473 NETDATA_VFS_CGROUP_GROUP,
@@ -474,6 +479,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
479
480 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
481 NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,
482 + "",
483 "Bytes written on disk",
484 EBPF_COMMON_DIMENSION_BYTES,
485 NETDATA_VFS_CGROUP_GROUP,
@@ -484,6 +490,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
490
491 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
492 NETDATA_SYSCALL_APPS_VFS_READ_BYTES,
493 + "",
494 "Bytes read from disk",
495 EBPF_COMMON_DIMENSION_BYTES,
496 NETDATA_VFS_CGROUP_GROUP,
@@ -494,7 +501,8 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
501
502 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
503 NETDATA_SYSCALL_APPS_VFS_FSYNC,
497 - "Calls to <code>vfs_fsync</code>",
504 + "",
505 + "Calls to vfs_fsync.",
506 EBPF_COMMON_DIMENSION_CALL,
507 NETDATA_VFS_CGROUP_GROUP,
508 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -505,6 +513,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
513 if (em->mode < MODE_ENTRY) {
514 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
515 NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,
516 + "",
517 "Sync error",
518 EBPF_COMMON_DIMENSION_CALL,
519 NETDATA_VFS_CGROUP_GROUP,
@@ -515,7 +524,8 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
524 }
525 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
526 NETDATA_SYSCALL_APPS_VFS_OPEN,
518 - "Calls to <code>vfs_open</code>",
527 + "",
528 + "Calls to vfs_open.",
529 EBPF_COMMON_DIMENSION_CALL,
530 NETDATA_VFS_CGROUP_GROUP,
531 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -526,6 +536,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
536 if (em->mode < MODE_ENTRY) {
537 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
538 NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,
539 + "",
540 "Open error",
541 EBPF_COMMON_DIMENSION_CALL,
542 NETDATA_VFS_CGROUP_GROUP,
@@ -537,7 +548,8 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
548
549 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
550 NETDATA_SYSCALL_APPS_VFS_CREATE,
540 - "Calls to <code>vfs_create</code>",
551 + "",
552 + "Calls to vfs_create.",
553 EBPF_COMMON_DIMENSION_CALL,
554 NETDATA_VFS_CGROUP_GROUP,
555 NETDATA_EBPF_CHART_TYPE_STACKED,
@@ -548,6 +560,7 @@ static void ebpf_obsolete_vfs_services(ebpf_module_t *em)
560 if (em->mode < MODE_ENTRY) {
561 ebpf_write_chart_obsolete(NETDATA_SERVICE_FAMILY,
562 NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,
563 + "",
564 "Create error",
565 EBPF_COMMON_DIMENSION_CALL,
566 NETDATA_VFS_CGROUP_GROUP,
@@ -589,144 +602,166 @@ static inline void ebpf_obsolete_vfs_cgroup_charts(ebpf_module_t *em) {
602 */
603 void ebpf_obsolete_vfs_apps_charts(struct ebpf_module *em)
604 {
592 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
593 - NETDATA_SYSCALL_APPS_FILE_DELETED,
594 - "Files deleted",
595 - EBPF_COMMON_DIMENSION_CALL,
596 - NETDATA_VFS_GROUP,
597 - NETDATA_EBPF_CHART_TYPE_STACKED,
598 - NULL,
599 - 20065,
600 - em->update_every);
601 -
602 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
603 - NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,
604 - "Write to disk",
605 - EBPF_COMMON_DIMENSION_CALL,
606 - NETDATA_VFS_GROUP,
607 - NETDATA_EBPF_CHART_TYPE_STACKED,
608 - NULL,
609 - 20066,
610 - em->update_every);
605 + int order = 20275;
606 + struct ebpf_target *w;
607 + int update_every = em->update_every;
608 + for (w = apps_groups_root_target; w; w = w->next) {
609 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_VFS_IDX))))
610 + continue;
611
612 - if (em->mode < MODE_ENTRY) {
613 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
614 - NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,
615 - "Fails to write",
612 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
613 + w->clean_name,
614 + "_ebpf_call_vfs_unlink",
615 + "Files deleted.",
616 EBPF_COMMON_DIMENSION_CALL,
617 NETDATA_VFS_GROUP,
618 NETDATA_EBPF_CHART_TYPE_STACKED,
619 - NULL,
620 - 20067,
621 - em->update_every);
622 - }
623 -
624 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
625 - NETDATA_SYSCALL_APPS_VFS_READ_CALLS,
626 - "Read from disk",
627 - EBPF_COMMON_DIMENSION_CALL,
628 - NETDATA_VFS_GROUP,
629 - NETDATA_EBPF_CHART_TYPE_STACKED,
630 - NULL,
631 - 20068,
632 - em->update_every);
633 -
634 - if (em->mode < MODE_ENTRY) {
635 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
636 - NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,
637 - "Fails to read",
619 + "app.ebpf_call_vfs_unlink",
620 + order++,
621 + update_every);
622 +
623 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
624 + w->clean_name,
625 + "_ebpf_call_vfs_write",
626 + "Write to disk.",
627 EBPF_COMMON_DIMENSION_CALL,
628 NETDATA_VFS_GROUP,
629 NETDATA_EBPF_CHART_TYPE_STACKED,
641 - NULL,
642 - 20069,
643 - em->update_every);
644 - }
645 -
646 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
647 - NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,
648 - "Bytes written on disk",
649 - EBPF_COMMON_DIMENSION_BYTES,
650 - NETDATA_VFS_GROUP,
651 - NETDATA_EBPF_CHART_TYPE_STACKED,
652 - NULL,
653 - 20070,
654 - em->update_every);
655 -
656 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
657 - NETDATA_SYSCALL_APPS_VFS_READ_BYTES,
658 - "Bytes read from disk",
659 - EBPF_COMMON_DIMENSION_BYTES,
660 - NETDATA_VFS_GROUP,
661 - NETDATA_EBPF_CHART_TYPE_STACKED,
662 - NULL,
663 - 20071,
664 - em->update_every);
665 -
666 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
667 - NETDATA_SYSCALL_APPS_VFS_FSYNC,
668 - "Calls for <code>vfs_fsync</code>",
669 - EBPF_COMMON_DIMENSION_CALL,
670 - NETDATA_VFS_GROUP,
671 - NETDATA_EBPF_CHART_TYPE_STACKED,
672 - NULL,
673 - 20072,
674 - em->update_every);
630 + "app.ebpf_call_vfs_write",
631 + order++,
632 + update_every);
633 +
634 + if (em->mode < MODE_ENTRY) {
635 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
636 + w->clean_name,
637 + "_ebpf_call_vfs_write_error",
638 + "Fails to write.",
639 + EBPF_COMMON_DIMENSION_CALL,
640 + NETDATA_VFS_GROUP,
641 + NETDATA_EBPF_CHART_TYPE_STACKED,
642 + "app.ebpf_call_vfs_write_error",
643 + order++,
644 + update_every);
645 + }
646
676 - if (em->mode < MODE_ENTRY) {
677 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
678 - NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,
679 - "Sync error",
647 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
648 + w->clean_name,
649 + "_ebpf_call_vfs_read",
650 + "Read from disk.",
651 EBPF_COMMON_DIMENSION_CALL,
652 NETDATA_VFS_GROUP,
653 NETDATA_EBPF_CHART_TYPE_STACKED,
683 - NULL,
684 - 20073,
685 - em->update_every);
686 - }
687 -
688 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
689 - NETDATA_SYSCALL_APPS_VFS_OPEN,
690 - "Calls for <code>vfs_open</code>",
691 - EBPF_COMMON_DIMENSION_CALL,
692 - NETDATA_VFS_GROUP,
693 - NETDATA_EBPF_CHART_TYPE_STACKED,
694 - NULL,
695 - 20074,
696 - em->update_every);
654 + "app.ebpf_call_vfs_read",
655 + order++,
656 + update_every);
657 +
658 + if (em->mode < MODE_ENTRY) {
659 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
660 + w->clean_name,
661 + "_ebpf_call_vfs_read_error",
662 + "Fails to read.",
663 + EBPF_COMMON_DIMENSION_CALL,
664 + NETDATA_VFS_GROUP,
665 + NETDATA_EBPF_CHART_TYPE_STACKED,
666 + "app.ebpf_call_vfs_read_error",
667 + order++,
668 + update_every);
669 + }
670
698 - if (em->mode < MODE_ENTRY) {
699 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
700 - NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,
701 - "Open error",
671 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
672 + w->clean_name,
673 + "_ebpf_call_vfs_write_bytes",
674 + "Bytes written on disk.",
675 + EBPF_COMMON_DIMENSION_BYTES,
676 + NETDATA_VFS_GROUP,
677 + NETDATA_EBPF_CHART_TYPE_STACKED,
678 + "app.ebpf_call_vfs_write_bytes",
679 + order++,
680 + update_every);
681 +
682 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
683 + w->clean_name,
684 + "_ebpf_call_vfs_read_bytes",
685 + "Bytes read from disk.",
686 + EBPF_COMMON_DIMENSION_BYTES,
687 + NETDATA_VFS_GROUP,
688 + NETDATA_EBPF_CHART_TYPE_STACKED,
689 + "app.ebpf_call_vfs_read_bytes",
690 + order++,
691 + update_every);
692 +
693 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
694 + w->clean_name,
695 + "_ebpf_call_vfs_fsync",
696 + "Calls to vfs_fsync.",
697 EBPF_COMMON_DIMENSION_CALL,
698 NETDATA_VFS_GROUP,
699 NETDATA_EBPF_CHART_TYPE_STACKED,
705 - NULL,
706 - 20075,
707 - em->update_every);
708 - }
700 + "app.ebpf_call_vfs_fsync",
701 + order++,
702 + update_every);
703 +
704 + if (em->mode < MODE_ENTRY) {
705 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
706 + w->clean_name,
707 + "_ebpf_call_vfs_fsync_error",
708 + "Fails to sync.",
709 + EBPF_COMMON_DIMENSION_CALL,
710 + NETDATA_VFS_GROUP,
711 + NETDATA_EBPF_CHART_TYPE_STACKED,
712 + "app.ebpf_call_vfs_fsync_error",
713 + order++,
714 + update_every);
715 + }
716
710 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
711 - NETDATA_SYSCALL_APPS_VFS_CREATE,
712 - "Calls for <code>vfs_create</code>",
713 - EBPF_COMMON_DIMENSION_CALL,
714 - NETDATA_VFS_GROUP,
715 - NETDATA_EBPF_CHART_TYPE_STACKED,
716 - NULL,
717 - 20076,
718 - em->update_every);
717 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
718 + w->clean_name,
719 + "_ebpf_call_vfs_open",
720 + "Calls to vfs_open.",
721 + EBPF_COMMON_DIMENSION_CALL,
722 + NETDATA_VFS_GROUP,
723 + NETDATA_EBPF_CHART_TYPE_STACKED,
724 + "app.ebpf_call_vfs_open",
725 + order++,
726 + update_every);
727 +
728 + if (em->mode < MODE_ENTRY) {
729 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
730 + w->clean_name,
731 + "_ebpf_call_vfs_open_error",
732 + "Fails to open.",
733 + EBPF_COMMON_DIMENSION_CALL,
734 + NETDATA_VFS_GROUP,
735 + NETDATA_EBPF_CHART_TYPE_STACKED,
736 + "app.ebpf_call_vfs_open_error",
737 + order++,
738 + update_every);
739 + }
740
720 - if (em->mode < MODE_ENTRY) {
721 - ebpf_write_chart_obsolete(NETDATA_APPS_FAMILY,
722 - NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,
723 - "Create error",
741 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
742 + w->clean_name,
743 + "_ebpf_call_vfs_create",
744 + "Calls to vfs_create.",
745 EBPF_COMMON_DIMENSION_CALL,
746 NETDATA_VFS_GROUP,
747 NETDATA_EBPF_CHART_TYPE_STACKED,
727 - NULL,
728 - 20077,
729 - em->update_every);
748 + "app.ebpf_call_vfs_create",
749 + order++,
750 + update_every);
751 +
752 + if (em->mode < MODE_ENTRY) {
753 + ebpf_write_chart_obsolete(NETDATA_APP_FAMILY,
754 + w->clean_name,
755 + "_ebpf_call_vfs_create_error",
756 + "Fails to create.",
757 + EBPF_COMMON_DIMENSION_CALL,
758 + NETDATA_VFS_GROUP,
759 + NETDATA_EBPF_CHART_TYPE_STACKED,
760 + "app.ebpf_call_vfs_create_error",
761 + order++,
762 + update_every);
763 + }
764 + w->charts_created &= ~(1<<EBPF_MODULE_VFS_IDX);
765 }
766 }
767
@@ -741,6 +776,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
776 {
777 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
778 NETDATA_VFS_FILE_CLEAN_COUNT,
779 + "",
780 "Remove files",
781 EBPF_COMMON_DIMENSION_CALL,
782 NETDATA_VFS_GROUP,
@@ -751,6 +787,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
787
788 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
789 NETDATA_VFS_FILE_IO_COUNT,
790 + "",
791 "Calls to IO",
792 EBPF_COMMON_DIMENSION_CALL,
793 NETDATA_VFS_GROUP,
@@ -761,6 +798,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
798
799 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
800 NETDATA_VFS_IO_FILE_BYTES,
801 + "",
802 "Bytes written and read",
803 EBPF_COMMON_DIMENSION_BYTES,
804 NETDATA_VFS_GROUP,
@@ -772,6 +810,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
810 if (em->mode < MODE_ENTRY) {
811 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
812 NETDATA_VFS_FILE_ERR_COUNT,
813 + "",
814 "Fails to write or read",
815 EBPF_COMMON_DIMENSION_CALL,
816 NETDATA_VFS_GROUP,
@@ -783,7 +822,8 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
822
823 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
824 NETDATA_VFS_FSYNC,
786 - "Calls for <code>vfs_fsync</code>",
825 + "",
826 + "Calls to vfs_fsync.",
827 EBPF_COMMON_DIMENSION_CALL,
828 NETDATA_VFS_GROUP,
829 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -794,6 +834,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
834 if (em->mode < MODE_ENTRY) {
835 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
836 NETDATA_VFS_FSYNC_ERR,
837 + "",
838 "Fails to synchronize",
839 EBPF_COMMON_DIMENSION_CALL,
840 NETDATA_VFS_GROUP,
@@ -805,7 +846,8 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
846
847 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
848 NETDATA_VFS_OPEN,
808 - "Calls for <code>vfs_open</code>",
849 + "",
850 + "Calls to vfs_open.",
851 EBPF_COMMON_DIMENSION_CALL,
852 NETDATA_VFS_GROUP,
853 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -816,6 +858,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
858 if (em->mode < MODE_ENTRY) {
859 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
860 NETDATA_VFS_OPEN_ERR,
861 + "",
862 "Fails to open a file",
863 EBPF_COMMON_DIMENSION_CALL,
864 NETDATA_VFS_GROUP,
@@ -827,7 +870,8 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
870
871 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
872 NETDATA_VFS_CREATE,
830 - "Calls for <code>vfs_create</code>",
873 + "",
874 + "Calls to vfs_create.",
875 EBPF_COMMON_DIMENSION_CALL,
876 NETDATA_VFS_GROUP,
877 NETDATA_EBPF_CHART_TYPE_LINE,
@@ -838,6 +882,7 @@ static void ebpf_obsolete_vfs_global(ebpf_module_t *em)
882 if (em->mode < MODE_ENTRY) {
883 ebpf_write_chart_obsolete(NETDATA_FILESYSTEM_FAMILY,
884 NETDATA_VFS_CREATE_ERR,
885 + "",
886 "Fails to create a file.",
887 EBPF_COMMON_DIMENSION_CALL,
888 NETDATA_VFS_GROUP,
@@ -1086,123 +1131,72 @@ void ebpf_vfs_send_apps_data(ebpf_module_t *em, struct ebpf_target *root)
1131 {
1132 struct ebpf_target *w;
1133 for (w = root; w; w = w->next) {
1089 - if (unlikely(w->exposed && w->processes)) {
1090 - ebpf_vfs_sum_pids(&w->vfs, w->root_pid);
1091 - }
1092 - }
1134 + if (unlikely(!(w->charts_created & (1<<EBPF_MODULE_VFS_IDX))))
1135 + continue;
1136
1094 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_FILE_DELETED);
1095 - for (w = root; w; w = w->next) {
1096 - if (unlikely(w->exposed && w->processes)) {
1097 - write_chart_dimension(w->name, w->vfs.unlink_call);
1098 - }
1099 - }
1100 - write_end_chart();
1137 + ebpf_vfs_sum_pids(&w->vfs, w->root_pid);
1138
1102 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS);
1103 - for (w = root; w; w = w->next) {
1104 - if (unlikely(w->exposed && w->processes)) {
1105 - write_chart_dimension(w->name, w->vfs.write_call + w->vfs.writev_call);
1106 - }
1107 - }
1108 - write_end_chart();
1139 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_unlink");
1140 + write_chart_dimension("calls", w->vfs.unlink_call);
1141 + ebpf_write_end_chart();
1142
1110 - if (em->mode < MODE_ENTRY) {
1111 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR);
1112 - for (w = root; w; w = w->next) {
1113 - if (unlikely(w->exposed && w->processes)) {
1114 - write_chart_dimension(w->name, w->vfs.write_err + w->vfs.writev_err);
1115 - }
1116 - }
1117 - write_end_chart();
1118 - }
1143 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_write");
1144 + write_chart_dimension("calls", w->vfs.write_call + w->vfs.writev_call);
1145 + ebpf_write_end_chart();
1146
1120 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS);
1121 - for (w = root; w; w = w->next) {
1122 - if (unlikely(w->exposed && w->processes)) {
1123 - write_chart_dimension(w->name, w->vfs.read_call + w->vfs.readv_call);
1147 + if (em->mode < MODE_ENTRY) {
1148 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_write_error");
1149 + write_chart_dimension("calls", w->vfs.write_err + w->vfs.writev_err);
1150 + ebpf_write_end_chart();
1151 }
1125 - }
1126 - write_end_chart();
1152
1128 - if (em->mode < MODE_ENTRY) {
1129 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR);
1130 - for (w = root; w; w = w->next) {
1131 - if (unlikely(w->exposed && w->processes)) {
1132 - write_chart_dimension(w->name, w->vfs.read_err + w->vfs.readv_err);
1133 - }
1134 - }
1135 - write_end_chart();
1136 - }
1153 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_read");
1154 + write_chart_dimension("calls", w->vfs.read_call + w->vfs.readv_call);
1155 + ebpf_write_end_chart();
1156
1138 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES);
1139 - for (w = root; w; w = w->next) {
1140 - if (unlikely(w->exposed && w->processes)) {
1141 - write_chart_dimension(w->name, w->vfs.write_bytes + w->vfs.writev_bytes);
1157 + if (em->mode < MODE_ENTRY) {
1158 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_read_error");
1159 + write_chart_dimension("calls", w->vfs.read_err + w->vfs.readv_err);
1160 + ebpf_write_end_chart();
1161 }
1143 - }
1144 - write_end_chart();
1162
1146 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_BYTES);
1147 - for (w = root; w; w = w->next) {
1148 - if (unlikely(w->exposed && w->processes)) {
1149 - write_chart_dimension(w->name, w->vfs.read_bytes + w->vfs.readv_bytes);
1150 - }
1151 - }
1152 - write_end_chart();
1163 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_write_bytes");
1164 + write_chart_dimension("writes", w->vfs.write_bytes + w->vfs.writev_bytes);
1165 + ebpf_write_end_chart();
1166
1154 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC);
1155 - for (w = root; w; w = w->next) {
1156 - if (unlikely(w->exposed && w->processes)) {
1157 - write_chart_dimension(w->name, w->vfs.fsync_call);
1158 - }
1159 - }
1160 - write_end_chart();
1167 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_read_bytes");
1168 + write_chart_dimension("reads", w->vfs.read_bytes + w->vfs.readv_bytes);
1169 + ebpf_write_end_chart();
1170
1162 - if (em->mode < MODE_ENTRY) {
1163 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR);
1164 - for (w = root; w; w = w->next) {
1165 - if (unlikely(w->exposed && w->processes)) {
1166 - write_chart_dimension(w->name, w->vfs.fsync_err);
1167 - }
1168 - }
1169 - write_end_chart();
1170 - }
1171 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_fsync");
1172 + write_chart_dimension("calls", w->vfs.fsync_call);
1173 + ebpf_write_end_chart();
1174
1172 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN);
1173 - for (w = root; w; w = w->next) {
1174 - if (unlikely(w->exposed && w->processes)) {
1175 - write_chart_dimension(w->name, w->vfs.open_call);
1175 + if (em->mode < MODE_ENTRY) {
1176 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_fsync_error");
1177 + write_chart_dimension("calls", w->vfs.fsync_err);
1178 + ebpf_write_end_chart();
1179 }
1177 - }
1178 - write_end_chart();
1180
1180 - if (em->mode < MODE_ENTRY) {
1181 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR);
1182 - for (w = root; w; w = w->next) {
1183 - if (unlikely(w->exposed && w->processes)) {
1184 - write_chart_dimension(w->name, w->vfs.open_err);
1185 - }
1186 - }
1187 - write_end_chart();
1188 - }
1181 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_open");
1182 + write_chart_dimension("calls", w->vfs.open_call);
1183 + ebpf_write_end_chart();
1184
1190 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE);
1191 - for (w = root; w; w = w->next) {
1192 - if (unlikely(w->exposed && w->processes)) {
1193 - write_chart_dimension(w->name, w->vfs.create_call);
1185 + if (em->mode < MODE_ENTRY) {
1186 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_open_error");
1187 + write_chart_dimension("calls", w->vfs.open_err);
1188 + ebpf_write_end_chart();
1189 }
1195 - }
1196 - write_end_chart();
1190
1198 - if (em->mode < MODE_ENTRY) {
1199 - write_begin_chart(NETDATA_APPS_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR);
1200 - for (w = root; w; w = w->next) {
1201 - if (unlikely(w->exposed && w->processes)) {
1202 - write_chart_dimension(w->name, w->vfs.create_err);
1203 - }
1191 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_create");
1192 + write_chart_dimension("calls", w->vfs.create_call);
1193 + ebpf_write_end_chart();
1194 +
1195 + if (em->mode < MODE_ENTRY) {
1196 + ebpf_write_begin_chart(NETDATA_APP_FAMILY, w->clean_name, "_ebpf_call_vfs_create_error");
1197 + write_chart_dimension("calls", w->vfs.create_err);
1198 + ebpf_write_end_chart();
1199 }
1205 - write_end_chart();
1200 }
1201 }
1202
@@ -1451,7 +1445,7 @@ static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)
1445 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ],
1446 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1447
1454 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls for <code>vfs_fsync</code>",
1448 + ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.",
1449 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_FSYNC_CONTEXT,
1450 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507,
1451 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC],
@@ -1465,7 +1459,7 @@ static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)
1459 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1460 }
1461
1468 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls for <code>vfs_open</code>",
1462 + ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.",
1463 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_OPEN_CONTEXT,
1464 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509,
1465 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN],
@@ -1479,7 +1473,7 @@ static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)
1473 1, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
1474 }
1475
1482 - ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls for <code>vfs_create</code>",
1476 + ebpf_create_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.",
1477 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP, NETDATA_CGROUP_VFS_CREATE_CONTEXT,
1478 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511,
1479 ebpf_create_global_dimension, &vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE],
@@ -1504,76 +1498,76 @@ static void ebpf_create_specific_vfs_charts(char *type, ebpf_module_t *em)
1498 */
1499 static void ebpf_obsolete_specific_vfs_charts(char *type, ebpf_module_t *em)
1500 {
1507 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_DELETED, "Files deleted",
1501 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_FILE_DELETED, "", "Files deleted",
1502 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1503 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_UNLINK_CONTEXT,
1504 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5500, em->update_every);
1505
1512 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "Write to disk",
1506 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "", "Write to disk",
1507 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1508 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_WRITE_CONTEXT,
1509 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5501, em->update_every);
1510
1511 if (em->mode < MODE_ENTRY) {
1518 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "Fails to write",
1512 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "", "Fails to write",
1513 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1514 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_WRITE_ERROR_CONTEXT,
1515 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5502, em->update_every);
1516 }
1517
1524 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "Read from disk",
1518 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "", "Read from disk",
1519 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1520 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_READ_CONTEXT,
1521 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5503, em->update_every);
1522
1523 if (em->mode < MODE_ENTRY) {
1530 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "Fails to read",
1524 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "", "Fails to read",
1525 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1526 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_READ_ERROR_CONTEXT,
1527 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5504, em->update_every);
1528 }
1529
1536 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "Bytes written on disk",
1530 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "", "Bytes written on disk",
1531 EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_GROUP,
1532 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_WRITE_BYTES_CONTEXT,
1533 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5505, em->update_every);
1534
1541 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "Bytes read from disk",
1535 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "", "Bytes read from disk",
1536 EBPF_COMMON_DIMENSION_BYTES, NETDATA_VFS_GROUP,
1537 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_READ_BYTES_CONTEXT,
1538 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5506, em->update_every);
1539
1546 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls for <code>vfs_fsync</code>",
1540 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "", "Calls to vfs_fsync.",
1541 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1542 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_FSYNC_CONTEXT,
1543 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5507, em->update_every);
1544
1545 if (em->mode < MODE_ENTRY) {
1552 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "Sync error",
1546 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "", "Sync error",
1547 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1548 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_FSYNC_ERROR_CONTEXT,
1549 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5508, em->update_every);
1550 }
1551
1558 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls for <code>vfs_open</code>",
1552 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "", "Calls to vfs_open.",
1553 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1554 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_OPEN_CONTEXT,
1555 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5509, em->update_every);
1556
1557 if (em->mode < MODE_ENTRY) {
1564 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "Open error",
1558 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "", "Open error",
1559 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1560 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_OPEN_ERROR_CONTEXT,
1561 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5510, em->update_every);
1562 }
1563
1570 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls for <code>vfs_create</code>",
1564 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "", "Calls to vfs_create.",
1565 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1566 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_CREATE_CONTEXT,
1567 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5511, em->update_every);
1568
1569 if (em->mode < MODE_ENTRY) {
1576 - ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "Create error",
1570 + ebpf_write_chart_obsolete(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "", "Create error",
1571 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_GROUP,
1572 NETDATA_EBPF_CHART_TYPE_LINE, NETDATA_CGROUP_VFS_CREATE_ERROR_CONTEXT,
1573 NETDATA_CHART_PRIO_CGROUPS_CONTAINERS + 5512, em->update_every);
@@ -1590,78 +1584,78 @@ static void ebpf_obsolete_specific_vfs_charts(char *type, ebpf_module_t *em)
1584 */
1585 static void ebpf_send_specific_vfs_data(char *type, netdata_publish_vfs_t *values, ebpf_module_t *em)
1586 {
1593 - write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_DELETED);
1587 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_FILE_DELETED, "");
1588 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_UNLINK].name, (long long)values->unlink_call);
1595 - write_end_chart();
1589 + ebpf_write_end_chart();
1590
1597 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS);
1591 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "");
1592 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,
1593 (long long)values->write_call + (long long)values->writev_call);
1600 - write_end_chart();
1594 + ebpf_write_end_chart();
1595
1596 if (em->mode < MODE_ENTRY) {
1603 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR);
1597 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "");
1598 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,
1599 (long long)values->write_err + (long long)values->writev_err);
1606 - write_end_chart();
1600 + ebpf_write_end_chart();
1601 }
1602
1609 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS);
1603 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "");
1604 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,
1605 (long long)values->read_call + (long long)values->readv_call);
1612 - write_end_chart();
1606 + ebpf_write_end_chart();
1607
1608 if (em->mode < MODE_ENTRY) {
1615 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR);
1609 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "");
1610 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,
1611 (long long)values->read_err + (long long)values->readv_err);
1618 - write_end_chart();
1612 + ebpf_write_end_chart();
1613 }
1614
1621 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES);
1615 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "");
1616 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_WRITE].name,
1617 (long long)values->write_bytes + (long long)values->writev_bytes);
1624 - write_end_chart();
1618 + ebpf_write_end_chart();
1619
1626 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES);
1620 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "");
1621 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_READ].name,
1622 (long long)values->read_bytes + (long long)values->readv_bytes);
1629 - write_end_chart();
1623 + ebpf_write_end_chart();
1624
1631 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC);
1625 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC, "");
1626 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].name,
1627 (long long)values->fsync_call);
1634 - write_end_chart();
1628 + ebpf_write_end_chart();
1629
1630 if (em->mode < MODE_ENTRY) {
1637 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR);
1631 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "");
1632 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_FSYNC].name,
1633 (long long)values->fsync_err);
1640 - write_end_chart();
1634 + ebpf_write_end_chart();
1635 }
1636
1643 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN);
1637 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN, "");
1638 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].name,
1639 (long long)values->open_call);
1646 - write_end_chart();
1640 + ebpf_write_end_chart();
1641
1642 if (em->mode < MODE_ENTRY) {
1649 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR);
1643 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "");
1644 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_OPEN].name,
1645 (long long)values->open_err);
1652 - write_end_chart();
1646 + ebpf_write_end_chart();
1647 }
1648
1655 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE);
1649 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE, "");
1650 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].name,
1651 (long long)values->create_call);
1658 - write_end_chart();
1652 + ebpf_write_end_chart();
1653
1654 if (em->mode < MODE_ENTRY) {
1661 - write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR);
1655 + ebpf_write_begin_chart(type, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "");
1656 write_chart_dimension(vfs_publish_aggregated[NETDATA_KEY_PUBLISH_VFS_CREATE].name,
1657 (long long)values->create_err);
1664 - write_end_chart();
1658 + ebpf_write_end_chart();
1659 }
1660 }
1661
@@ -1722,7 +1716,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)
1716 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_READ_BYTES_CONTEXT,
1717 NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1718
1725 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to <code>vfs_fsync</code>",
1719 + ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_FSYNC, "Calls to vfs_fsync.",
1720 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1721 NETDATA_EBPF_CHART_TYPE_STACKED, 20072,
1722 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_FSYNC_CONTEXT,
@@ -1735,7 +1729,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)
1729 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_FSYNC_ERROR_CONTEXT,
1730 NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1731 }
1738 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to <code>vfs_open</code>",
1732 + ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_OPEN, "Calls to vfs_open.",
1733 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1734 NETDATA_EBPF_CHART_TYPE_STACKED, 20074,
1735 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_OPEN_CONTEXT,
@@ -1749,7 +1743,7 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)
1743 NETDATA_EBPF_MODULE_NAME_VFS, em->update_every);
1744 }
1745
1752 - ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to <code>vfs_create</code>",
1746 + ebpf_create_charts_on_systemd(NETDATA_SYSCALL_APPS_VFS_CREATE, "Calls to vfs_create.",
1747 EBPF_COMMON_DIMENSION_CALL, NETDATA_VFS_CGROUP_GROUP,
1748 NETDATA_EBPF_CHART_TYPE_STACKED, 20076,
1749 ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX], NETDATA_SYSTEMD_VFS_CREATE_CONTEXT,
@@ -1774,125 +1768,124 @@ static void ebpf_create_systemd_vfs_charts(ebpf_module_t *em)
1768 static void ebpf_send_systemd_vfs_charts(ebpf_module_t *em)
1769 {
1770 ebpf_cgroup_target_t *ect;
1777 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_DELETED);
1771 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_FILE_DELETED, "");
1772 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1773 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1774 write_chart_dimension(ect->name, ect->publish_systemd_vfs.unlink_call);
1775 }
1776 }
1783 - write_end_chart();
1777 + ebpf_write_end_chart();
1778
1785 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS);
1779 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS, "");
1780 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1781 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1782 write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_call +
1783 ect->publish_systemd_vfs.writev_call);
1784 }
1785 }
1792 - write_end_chart();
1786 + ebpf_write_end_chart();
1787
1788 if (em->mode < MODE_ENTRY) {
1795 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR);
1789 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR, "");
1790 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1791 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1792 write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_err +
1793 ect->publish_systemd_vfs.writev_err);
1794 }
1795 }
1802 - write_end_chart();
1796 + ebpf_write_end_chart();
1797 }
1798
1805 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS);
1799 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS, "");
1800 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1801 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1802 write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_call +
1803 ect->publish_systemd_vfs.readv_call);
1804 }
1805 }
1812 - write_end_chart();
1806 + ebpf_write_end_chart();
1807
1808 if (em->mode < MODE_ENTRY) {
1815 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR);
1809 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR, "");
1810 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1811 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1812 write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_err +
1813 ect->publish_systemd_vfs.readv_err);
1814 }
1815 }
1822 - write_end_chart();
1816 + ebpf_write_end_chart();
1817 }
1818
1825 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES);
1819 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES, "");
1820 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1821 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1822 write_chart_dimension(ect->name, ect->publish_systemd_vfs.write_bytes +
1823 ect->publish_systemd_vfs.writev_bytes);
1824 }
1825 }
1832 - write_end_chart();
1826 + ebpf_write_end_chart();
1827
1834 -
1835 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_BYTES);
1828 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_READ_BYTES, "");
1829 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1830 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1831 write_chart_dimension(ect->name, ect->publish_systemd_vfs.read_bytes +
1832 ect->publish_systemd_vfs.readv_bytes);
1833 }
1834 }
1842 - write_end_chart();
1835 + ebpf_write_end_chart();
1836
1844 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC);
1837 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC, "");
1838 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1839 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1840 write_chart_dimension(ect->name, ect->publish_systemd_vfs.fsync_call);
1841 }
1842 }
1850 - write_end_chart();
1843 + ebpf_write_end_chart();
1844
1845 if (em->mode < MODE_ENTRY) {
1853 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR);
1846 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR, "");
1847 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1848 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1849 write_chart_dimension(ect->name, ect->publish_systemd_vfs.fsync_err);
1850 }
1851 }
1859 - write_end_chart();
1852 + ebpf_write_end_chart();
1853 }
1854
1862 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN);
1855 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN, "");
1856 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1857 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1858 write_chart_dimension(ect->name, ect->publish_systemd_vfs.open_call);
1859 }
1860 }
1868 - write_end_chart();
1861 + ebpf_write_end_chart();
1862
1863 if (em->mode < MODE_ENTRY) {
1871 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR);
1864 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR, "");
1865 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1866 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1867 write_chart_dimension(ect->name, ect->publish_systemd_vfs.open_err);
1868 }
1869 }
1877 - write_end_chart();
1870 + ebpf_write_end_chart();
1871 }
1872
1880 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE);
1873 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE, "");
1874 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1875 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1876 write_chart_dimension(ect->name, ect->publish_systemd_vfs.create_call);
1877 }
1878 }
1886 - write_end_chart();
1879 + ebpf_write_end_chart();
1880
1881 if (em->mode < MODE_ENTRY) {
1889 - write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR);
1882 + ebpf_write_begin_chart(NETDATA_SERVICE_FAMILY, NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR, "");
1883 for (ect = ebpf_cgroup_pids; ect ; ect = ect->next) {
1884 if (unlikely(ect->systemd) && unlikely(ect->updated)) {
1885 write_chart_dimension(ect->name, ect->publish_systemd_vfs.create_err);
1886 }
1887 }
1895 - write_end_chart();
1888 + ebpf_write_end_chart();
1889 }
1890 }
1891
@@ -2098,7 +2091,7 @@ static void ebpf_create_global_charts(ebpf_module_t *em)
2091
2092 ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,
2093 NETDATA_VFS_FSYNC,
2101 - "Calls for <code>vfs_fsync</code>",
2094 + "Calls to vfs_fsync.",
2095 EBPF_COMMON_DIMENSION_CALL,
2096 NETDATA_VFS_GROUP,
2097 NULL,
@@ -2124,7 +2117,7 @@ static void ebpf_create_global_charts(ebpf_module_t *em)
2117
2118 ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,
2119 NETDATA_VFS_OPEN,
2127 - "Calls for <code>vfs_open</code>",
2120 + "Calls to vfs_open.",
2121 EBPF_COMMON_DIMENSION_CALL,
2122 NETDATA_VFS_GROUP,
2123 NULL,
@@ -2150,7 +2143,7 @@ static void ebpf_create_global_charts(ebpf_module_t *em)
2143
2144 ebpf_create_chart(NETDATA_FILESYSTEM_FAMILY,
2145 NETDATA_VFS_CREATE,
2153 - "Calls for <code>vfs_create</code>",
2146 + "Calls to vfs_create.",
2147 EBPF_COMMON_DIMENSION_CALL,
2148 NETDATA_VFS_GROUP,
2149 NULL,
@@ -2188,127 +2181,219 @@ static void ebpf_create_global_charts(ebpf_module_t *em)
2181 void ebpf_vfs_create_apps_charts(struct ebpf_module *em, void *ptr)
2182 {
2183 struct ebpf_target *root = ptr;
2184 + struct ebpf_target *w;
2185 + int order = 20275;
2186 + int update_every = em->update_every;
2187 + for (w = root; w; w = w->next) {
2188 + if (unlikely(!w->exposed))
2189 + continue;
2190
2192 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_FILE_DELETED,
2193 - "Files deleted",
2194 - EBPF_COMMON_DIMENSION_CALL,
2195 - NETDATA_VFS_GROUP,
2196 - NETDATA_EBPF_CHART_TYPE_STACKED,
2197 - 20065,
2198 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2199 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2200 -
2201 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS,
2202 - "Write to disk",
2203 - EBPF_COMMON_DIMENSION_CALL,
2204 - NETDATA_VFS_GROUP,
2205 - NETDATA_EBPF_CHART_TYPE_STACKED,
2206 - 20066,
2207 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2208 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2191 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2192 + w->clean_name,
2193 + "_ebpf_call_vfs_unlink",
2194 + "Files deleted.",
2195 + EBPF_COMMON_DIMENSION_CALL,
2196 + NETDATA_VFS_GROUP,
2197 + NETDATA_EBPF_CHART_TYPE_STACKED,
2198 + "app.ebpf_call_vfs_unlink",
2199 + order++,
2200 + update_every,
2201 + NETDATA_EBPF_MODULE_NAME_VFS);
2202 + ebpf_create_chart_labels("app_group", w->name, 0);
2203 + ebpf_commit_label();
2204 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2205 +
2206 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2207 + w->clean_name,
2208 + "_ebpf_call_vfs_write",
2209 + "Write to disk.",
2210 + EBPF_COMMON_DIMENSION_CALL,
2211 + NETDATA_VFS_GROUP,
2212 + NETDATA_EBPF_CHART_TYPE_STACKED,
2213 + "app.ebpf_call_vfs_write",
2214 + order++,
2215 + update_every,
2216 + NETDATA_EBPF_MODULE_NAME_VFS);
2217 + ebpf_create_chart_labels("app_group", w->name, 0);
2218 + ebpf_commit_label();
2219 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2220 +
2221 + if (em->mode < MODE_ENTRY) {
2222 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2223 + w->clean_name,
2224 + "_ebpf_call_vfs_write_error",
2225 + "Fails to write.",
2226 + EBPF_COMMON_DIMENSION_CALL,
2227 + NETDATA_VFS_GROUP,
2228 + NETDATA_EBPF_CHART_TYPE_STACKED,
2229 + "app.ebpf_call_vfs_write_error",
2230 + order++,
2231 + update_every,
2232 + NETDATA_EBPF_MODULE_NAME_VFS);
2233 + ebpf_create_chart_labels("app_group", w->name, 0);
2234 + ebpf_commit_label();
2235 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2236 + }
2237
2210 - if (em->mode < MODE_ENTRY) {
2211 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_WRITE_CALLS_ERROR,
2212 - "Fails to write",
2213 - EBPF_COMMON_DIMENSION_CALL,
2214 - NETDATA_VFS_GROUP,
2215 - NETDATA_EBPF_CHART_TYPE_STACKED,
2216 - 20067,
2217 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2218 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2219 - }
2220 -
2221 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_READ_CALLS,
2222 - "Read from disk",
2223 - EBPF_COMMON_DIMENSION_CALL,
2224 - NETDATA_VFS_GROUP,
2225 - NETDATA_EBPF_CHART_TYPE_STACKED,
2226 - 20068,
2227 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2228 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2238 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2239 + w->clean_name,
2240 + "_ebpf_call_vfs_read",
2241 + "Read from disk.",
2242 + EBPF_COMMON_DIMENSION_CALL,
2243 + NETDATA_VFS_GROUP,
2244 + NETDATA_EBPF_CHART_TYPE_STACKED,
2245 + "app.ebpf_call_vfs_read",
2246 + order++,
2247 + update_every,
2248 + NETDATA_EBPF_MODULE_NAME_VFS);
2249 + ebpf_create_chart_labels("app_group", w->name, 0);
2250 + ebpf_commit_label();
2251 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2252 +
2253 + if (em->mode < MODE_ENTRY) {
2254 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2255 + w->clean_name,
2256 + "_ebpf_call_vfs_read_error",
2257 + "Fails to read.",
2258 + EBPF_COMMON_DIMENSION_CALL,
2259 + NETDATA_VFS_GROUP,
2260 + NETDATA_EBPF_CHART_TYPE_STACKED,
2261 + "app.ebpf_call_vfs_read_error",
2262 + order++,
2263 + update_every,
2264 + NETDATA_EBPF_MODULE_NAME_VFS);
2265 + ebpf_create_chart_labels("app_group", w->name, 0);
2266 + ebpf_commit_label();
2267 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2268 + }
2269
2230 - if (em->mode < MODE_ENTRY) {
2231 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_READ_CALLS_ERROR,
2232 - "Fails to read",
2233 - EBPF_COMMON_DIMENSION_CALL,
2234 - NETDATA_VFS_GROUP,
2235 - NETDATA_EBPF_CHART_TYPE_STACKED,
2236 - 20069,
2237 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2238 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2239 - }
2240 -
2241 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_WRITE_BYTES,
2242 - "Bytes written on disk", EBPF_COMMON_DIMENSION_BYTES,
2243 - NETDATA_VFS_GROUP,
2244 - NETDATA_EBPF_CHART_TYPE_STACKED,
2245 - 20070,
2246 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2247 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2248 -
2249 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_READ_BYTES,
2250 - "Bytes read from disk", EBPF_COMMON_DIMENSION_BYTES,
2251 - NETDATA_VFS_GROUP,
2252 - NETDATA_EBPF_CHART_TYPE_STACKED,
2253 - 20071,
2254 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2255 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2256 -
2257 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_FSYNC,
2258 - "Calls for <code>vfs_fsync</code>", EBPF_COMMON_DIMENSION_CALL,
2259 - NETDATA_VFS_GROUP,
2260 - NETDATA_EBPF_CHART_TYPE_STACKED,
2261 - 20072,
2262 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2263 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2270 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2271 + w->clean_name,
2272 + "_ebpf_call_vfs_write_bytes",
2273 + "Bytes written on disk.",
2274 + EBPF_COMMON_DIMENSION_BYTES,
2275 + NETDATA_VFS_GROUP,
2276 + NETDATA_EBPF_CHART_TYPE_STACKED,
2277 + "app.ebpf_call_vfs_write_bytes",
2278 + order++,
2279 + update_every,
2280 + NETDATA_EBPF_MODULE_NAME_VFS);
2281 + ebpf_create_chart_labels("app_group", w->name, 0);
2282 + ebpf_commit_label();
2283 + fprintf(stdout, "DIMENSION writes '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2284 +
2285 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2286 + w->clean_name,
2287 + "_ebpf_call_vfs_read_bytes",
2288 + "Bytes read from disk.",
2289 + EBPF_COMMON_DIMENSION_BYTES,
2290 + NETDATA_VFS_GROUP,
2291 + NETDATA_EBPF_CHART_TYPE_STACKED,
2292 + "app.ebpf_call_vfs_read_bytes",
2293 + order++,
2294 + update_every,
2295 + NETDATA_EBPF_MODULE_NAME_VFS);
2296 + ebpf_create_chart_labels("app_group", w->name, 0);
2297 + ebpf_commit_label();
2298 + fprintf(stdout, "DIMENSION reads '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2299 +
2300 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2301 + w->clean_name,
2302 + "_ebpf_call_vfs_fsync",
2303 + "Calls to vfs_fsync.",
2304 + EBPF_COMMON_DIMENSION_CALL,
2305 + NETDATA_VFS_GROUP,
2306 + NETDATA_EBPF_CHART_TYPE_STACKED,
2307 + "app.ebpf_call_vfs_fsync",
2308 + order++,
2309 + update_every,
2310 + NETDATA_EBPF_MODULE_NAME_VFS);
2311 + ebpf_create_chart_labels("app_group", w->name, 0);
2312 + ebpf_commit_label();
2313 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2314 +
2315 + if (em->mode < MODE_ENTRY) {
2316 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2317 + w->clean_name,
2318 + "_ebpf_call_vfs_fsync_error",
2319 + "Fails to sync.",
2320 + EBPF_COMMON_DIMENSION_CALL,
2321 + NETDATA_VFS_GROUP,
2322 + NETDATA_EBPF_CHART_TYPE_STACKED,
2323 + "app.ebpf_call_vfs_fsync_error",
2324 + order++,
2325 + update_every,
2326 + NETDATA_EBPF_MODULE_NAME_VFS);
2327 + ebpf_create_chart_labels("app_group", w->name, 0);
2328 + ebpf_commit_label();
2329 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2330 + }
2331
2265 - if (em->mode < MODE_ENTRY) {
2266 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_FSYNC_CALLS_ERROR,
2267 - "Sync error",
2268 - EBPF_COMMON_DIMENSION_CALL,
2269 - NETDATA_VFS_GROUP,
2270 - NETDATA_EBPF_CHART_TYPE_STACKED,
2271 - 20073,
2272 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2273 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2274 - }
2275 -
2276 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_OPEN,
2277 - "Calls for <code>vfs_open</code>", EBPF_COMMON_DIMENSION_CALL,
2278 - NETDATA_VFS_GROUP,
2279 - NETDATA_EBPF_CHART_TYPE_STACKED,
2280 - 20074,
2281 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2282 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2332 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2333 + w->clean_name,
2334 + "_ebpf_call_vfs_open",
2335 + "Calls to vfs_open.",
2336 + EBPF_COMMON_DIMENSION_CALL,
2337 + NETDATA_VFS_GROUP,
2338 + NETDATA_EBPF_CHART_TYPE_STACKED,
2339 + "app.ebpf_call_vfs_open",
2340 + order++,
2341 + update_every,
2342 + NETDATA_EBPF_MODULE_NAME_VFS);
2343 + ebpf_create_chart_labels("app_group", w->name, 0);
2344 + ebpf_commit_label();
2345 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2346 +
2347 + if (em->mode < MODE_ENTRY) {
2348 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2349 + w->clean_name,
2350 + "_ebpf_call_vfs_open_error",
2351 + "Fails to open.",
2352 + EBPF_COMMON_DIMENSION_CALL,
2353 + NETDATA_VFS_GROUP,
2354 + NETDATA_EBPF_CHART_TYPE_STACKED,
2355 + "app.ebpf_call_vfs_open_error",
2356 + order++,
2357 + update_every,
2358 + NETDATA_EBPF_MODULE_NAME_VFS);
2359 + ebpf_create_chart_labels("app_group", w->name, 0);
2360 + ebpf_commit_label();
2361 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2362 + }
2363
2284 - if (em->mode < MODE_ENTRY) {
2285 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_OPEN_CALLS_ERROR,
2286 - "Open error",
2287 - EBPF_COMMON_DIMENSION_CALL,
2288 - NETDATA_VFS_GROUP,
2289 - NETDATA_EBPF_CHART_TYPE_STACKED,
2290 - 20075,
2291 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2292 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2293 - }
2294 -
2295 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_CREATE,
2296 - "Calls for <code>vfs_create</code>", EBPF_COMMON_DIMENSION_CALL,
2297 - NETDATA_VFS_GROUP,
2298 - NETDATA_EBPF_CHART_TYPE_STACKED,
2299 - 20076,
2300 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2301 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2364 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2365 + w->clean_name,
2366 + "_ebpf_call_vfs_create",
2367 + "Calls to vfs_create.",
2368 + EBPF_COMMON_DIMENSION_CALL,
2369 + NETDATA_VFS_GROUP,
2370 + NETDATA_EBPF_CHART_TYPE_STACKED,
2371 + "app.ebpf_call_vfs_create",
2372 + order++,
2373 + update_every,
2374 + NETDATA_EBPF_MODULE_NAME_VFS);
2375 + ebpf_create_chart_labels("app_group", w->name, 0);
2376 + ebpf_commit_label();
2377 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2378 +
2379 + if (em->mode < MODE_ENTRY) {
2380 + ebpf_write_chart_cmd(NETDATA_APP_FAMILY,
2381 + w->clean_name,
2382 + "_ebpf_call_vfs_create_error",
2383 + "Fails to create a file.",
2384 + EBPF_COMMON_DIMENSION_CALL,
2385 + NETDATA_VFS_GROUP,
2386 + NETDATA_EBPF_CHART_TYPE_STACKED,
2387 + "app.ebpf_call_vfs_create_error",
2388 + order++,
2389 + update_every,
2390 + NETDATA_EBPF_MODULE_NAME_VFS);
2391 + ebpf_create_chart_labels("app_group", w->name, 0);
2392 + ebpf_commit_label();
2393 + fprintf(stdout, "DIMENSION calls '' %s 1 1\n", ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX]);
2394 + }
2395
2303 - if (em->mode < MODE_ENTRY) {
2304 - ebpf_create_charts_on_apps(NETDATA_SYSCALL_APPS_VFS_CREATE_CALLS_ERROR,
2305 - "Create error",
2306 - EBPF_COMMON_DIMENSION_CALL,
2307 - NETDATA_VFS_GROUP,
2308 - NETDATA_EBPF_CHART_TYPE_STACKED,
2309 - 20077,
2310 - ebpf_algorithms[NETDATA_EBPF_INCREMENTAL_IDX],
2311 - root, em->update_every, NETDATA_EBPF_MODULE_NAME_VFS);
2396 + w->charts_created |= 1<<EBPF_MODULE_VFS_IDX;
2397 }
2398
2399 em->apps_charts |= NETDATA_EBPF_APPS_FLAG_CHART_CREATED;
collectors/ebpf.plugin/metadata.yaml
+151 -139
@@ -196,32 +196,34 @@ modules:
196 - name: close
197 - name: apps
198 description: "These Metrics show grouped information per apps group."
199 - labels: []
199 + labels:
200 + - name: app_group
201 + description: The name of the group defined in the configuration.
202 metrics:
201 - - name: apps.file_open
203 + - name: app.ebpf_file_open
204 description: Number of open files
205 unit: "calls/s"
206 chart_type: stacked
207 dimensions:
206 - - name: a dimension per app group
207 - - name: apps.file_open_error
208 + - name: calls
209 + - name: app.ebpf_file_open_error
210 description: Fails to open files
211 unit: "calls/s"
212 chart_type: stacked
213 dimensions:
212 - - name: a dimension per app group
213 - - name: apps.file_closed
214 + - name: calls
215 + - name: app.ebpf_file_closed
216 description: Files closed
217 unit: "calls/s"
218 chart_type: stacked
219 dimensions:
218 - - name: a dimension per app group
219 - - name: apps.file_close_error
220 + - name: calls
221 + - name: app.ebpf_file_close_error
222 description: Fails to close files
223 unit: "calls/s"
224 chart_type: stacked
225 dimensions:
224 - - name: a dimension per app group
226 + - name: calls
227 - meta:
228 plugin_name: ebpf.plugin
229 module_name: processes
@@ -379,38 +381,40 @@ modules:
381 - name: task
382 - name: apps
383 description: "These Metrics show grouped information per apps group."
382 - labels: []
384 + labels:
385 + - name: app_group
386 + description: The name of the group defined in the configuration.
387 metrics:
384 - - name: apps.process_create
388 + - name: app.process_create
389 description: Process started
390 unit: "calls/s"
391 chart_type: stacked
392 dimensions:
389 - - name: a dimension per app group
390 - - name: apps.thread_create
393 + - name: calls
394 + - name: app.thread_create
395 description: Threads started
396 unit: "calls/s"
397 chart_type: stacked
398 dimensions:
395 - - name: a dimension per app group
396 - - name: apps.task_exit
399 + - name: call
400 + - name: app.task_exit
401 description: Tasks starts exit process
402 unit: "calls/s"
403 chart_type: stacked
404 dimensions:
401 - - name: a dimension per app group
402 - - name: apps.task_close
405 + - name: callp
406 + - name: app.task_close
407 description: Tasks closed
408 unit: "calls/s"
409 chart_type: stacked
410 dimensions:
407 - - name: a dimension per app group
408 - - name: apps.task_error
411 + - name: call
412 + - name: app.task_error
413 description: Errors to create process or threads
414 unit: "calls/s"
415 chart_type: stacked
416 dimensions:
413 - - name: a dimension per app group
417 + - name: app
418 - name: cgroup
419 description: "These Metrics show grouped information per cgroup/service."
420 labels: []
@@ -841,32 +845,34 @@ modules:
845 - name: miss
846 - name: apps
847 description: "These Metrics show grouped information per apps group."
844 - labels: []
848 + labels:
849 + - name: app_group
850 + description: The name of the group defined in the configuration.
851 metrics:
846 - - name: apps.cachestat_ratio
852 + - name: app.ebpf_cachestat_hit_ratio
853 description: Hit ratio
854 unit: "%"
855 chart_type: line
856 dimensions:
851 - - name: a dimension per app group
852 - - name: apps.cachestat_dirties
857 + - name: ratio
858 + - name: app.ebpf_cachestat_dirty_pages
859 description: Number of dirty pages
860 unit: "page/s"
861 chart_type: stacked
862 dimensions:
857 - - name: a dimension per app group
858 - - name: apps.cachestat_hits
863 + - name: pages
864 + - name: app.ebpf_cachestat_access
865 description: Number of accessed files
866 unit: "hits/s"
867 chart_type: stacked
868 dimensions:
863 - - name: a dimension per app group
864 - - name: apps.cachestat_misses
869 + - name: hits
870 + - name: app.ebpf_cachestat_misses
871 description: Files out of page cache
872 unit: "misses/s"
873 chart_type: stacked
874 dimensions:
869 - - name: a dimension per app group
875 + - name: misses
876 - name: cgroup
877 description: ""
878 labels: []
@@ -1076,27 +1082,27 @@ modules:
1082 labels: []
1083 metrics:
1084 - name: mem.file_sync
1079 - description: Monitor calls for <code>fsync(2)</code> and <code>fdatasync(2)</code>.
1085 + description: Monitor calls to fsync(2) and fdatasync(2).
1086 unit: "calls/s"
1087 chart_type: stacked
1088 dimensions:
1089 - name: fsync
1090 - name: fdatasync
1091 - name: mem.meory_map
1086 - description: Monitor calls for <code>msync(2)</code>.
1092 + description: Monitor calls to msync(2).
1093 unit: "calls/s"
1094 chart_type: line
1095 dimensions:
1096 - name: msync
1097 - name: mem.sync
1092 - description: Monitor calls for <code>sync(2)</code> and <code>syncfs(2)</code>.
1098 + description: Monitor calls to sync(2) and syncfs(2).
1099 unit: "calls/s"
1100 chart_type: line
1101 dimensions:
1102 - name: sync
1103 - name: syncfs
1104 - name: mem.file_segment
1099 - description: Monitor calls for <code>sync_file_range(2)</code>.
1105 + description: Monitor calls to sync_file_range(2).
1106 unit: "calls/s"
1107 chart_type: line
1108 dimensions:
@@ -1333,41 +1339,43 @@ modules:
1339 labels: []
1340 metrics:
1341 - name: cgroup.swap_read
1336 - description: Calls to function <code>swap_readpage</code>.
1342 + description: Calls to function swap_readpage.
1343 unit: "calls/s"
1344 chart_type: line
1345 dimensions:
1346 - name: read
1347 - name: cgroup.swap_write
1342 - description: Calls to function <code>swap_writepage</code>.
1348 + description: Calls to function swap_writepage.
1349 unit: "calls/s"
1350 chart_type: line
1351 dimensions:
1352 - name: write
1353 - name: services.swap_read
1348 - description: Calls to <code>swap_readpage</code>.
1354 + description: Calls to swap_readpage.
1355 unit: "calls/s"
1356 chart_type: stacked
1357 dimensions:
1358 - name: a dimension per systemd service
1359 - name: services.swap_write
1354 - description: Calls to function <code>swap_writepage</code>.
1360 + description: Calls to function swap_writepage.
1361 unit: "calls/s"
1362 chart_type: stacked
1363 dimensions:
1364 - name: a dimension per systemd service
1365 - name: apps
1366 description: "These Metrics show grouped information per apps group."
1361 - labels: []
1367 + labels:
1368 + - name: app_group
1369 + description: The name of the group defined in the configuration.
1370 metrics:
1363 - - name: apps.swap_read_call
1364 - description: Calls to function <code>swap_readpage</code>.
1371 + - name: app.ebpf_call_swap_readpage
1372 + description: Calls to function swap_readpage.
1373 unit: "calls/s"
1374 chart_type: stacked
1375 dimensions:
1376 - name: a dimension per app group
1369 - - name: apps.swap_write_call
1370 - description: Calls to function <code>swap_writepage</code>.
1377 + - name: app.ebpf_call_swap_writepage
1378 + description: Calls to function swap_writepage.
1379 unit: "calls/s"
1380 chart_type: stacked
1381 dimensions:
@@ -1501,14 +1509,16 @@ modules:
1509 - name: a dimension per systemd service
1510 - name: apps
1511 description: "These metrics show cgroup/service that reached OOM."
1504 - labels: []
1512 + labels:
1513 + - name: app_group
1514 + description: The name of the group defined in the configuration.
1515 metrics:
1506 - - name: apps.oomkills
1516 + - name: app.oomkill
1517 description: OOM kills
1518 unit: "kills"
1519 chart_type: stacked
1520 dimensions:
1511 - - name: a dimension per app group
1521 + - name: kills
1522 - meta:
1523 plugin_name: ebpf.plugin
1524 module_name: socket
@@ -1713,68 +1723,64 @@ modules:
1723 - name: send
1724 - name: apps
1725 description: "These metrics show grouped information per apps group."
1716 - labels: []
1726 + labels:
1727 + - name: app_group
1728 + description: The name of the group defined in the configuration.
1729 metrics:
1718 - - name: apps.outbound_conn_v4
1730 + - name: app.ebpf_call_tcp_v4_connection
1731 description: Calls to tcp_v4_connection
1732 unit: "connections/s"
1733 chart_type: stacked
1734 dimensions:
1723 - - name: a dimension per app group
1724 - - name: apps.outbound_conn_v6
1735 + - name: connections
1736 + - name: app.app.ebpf_call_tcp_v6_connection
1737 description: Calls to tcp_v6_connection
1738 unit: "connections/s"
1739 chart_type: stacked
1740 dimensions:
1729 - - name: a dimension per app group
1730 - - name: apps.total_bandwidth_sent
1741 + - name: connections
1742 + - name: app.ebpf_sock_bytes_sent
1743 description: Bytes sent
1744 unit: "kilobits/s"
1745 chart_type: stacked
1746 dimensions:
1735 - - name: a dimension per app group
1736 - - name: apps.total_bandwidth_recv
1747 + - name: bandwidth
1748 + - name: app.ebpf_sock_bytes_received
1749 description: bytes received
1750 unit: "kilobits/s"
1751 chart_type: stacked
1752 dimensions:
1741 - - name: a dimension per app group
1742 - - name: apps.bandwidth_tcp_send
1753 + - name: bandwidth
1754 + - name: app.ebpf_call_tcp_sendmsg
1755 description: Calls for tcp_sendmsg
1756 unit: "calls/s"
1757 chart_type: stacked
1758 dimensions:
1747 - - name: a dimension per app group
1748 - - name: apps.bandwidth_tcp_recv
1759 + - name: calls
1760 + - name: app.ebpf_call_tcp_cleanup_rbuf
1761 description: Calls for tcp_cleanup_rbuf
1762 unit: "calls/s"
1763 chart_type: stacked
1764 dimensions:
1753 - - name: a dimension per app group
1754 - - name: apps.bandwidth_tcp_retransmit
1765 + - name: calls
1766 + - name: app.ebpf_call_tcp_retransmit
1767 description: Calls for tcp_retransmit
1768 unit: "calls/s"
1769 chart_type: stacked
1770 dimensions:
1759 - - name: a dimension per app group
1760 - - name: apps.bandwidth_udp_send
1771 + - name: calls
1772 + - name: app.ebpf_call_udp_sendmsg
1773 description: Calls for udp_sendmsg
1774 unit: "calls/s"
1775 chart_type: stacked
1776 dimensions:
1765 - - name: a dimension per app group
1766 - - name: apps.bandwidth_udp_recv
1777 + - name: calls
1778 + - name: app.ebpf_call_udp_recvmsg
1779 description: Calls for udp_recvmsg
1780 unit: "calls/s"
1781 chart_type: stacked
1782 dimensions:
1771 - - name: a dimension per app group
1772 - - name: services.net_conn_ipv4
1773 - description: Calls to tcp_v4_connection
1774 - unit: "connections/s"
1775 - chart_type: stacked
1776 - dimensions:
1777 - - name: a dimension per systemd service
1783 + - name: calls
1784 - name: cgroup
1785 description: ""
1786 labels: []
@@ -2005,32 +2011,34 @@ modules:
2011 scopes:
2012 - name: apps
2013 description: "These Metrics show grouped information per apps group."
2008 - labels: []
2014 + labels:
2015 + - name: app_group
2016 + description: The name of the group defined in the configuration.
2017 metrics:
2010 - - name: apps.dc_ratio
2018 + - name: app.ebpf_dc_ratio
2019 description: Percentage of files inside directory cache
2020 unit: "%"
2021 chart_type: line
2022 dimensions:
2015 - - name: a dimension per app group
2016 - - name: apps.dc_reference
2023 + - name: ratio
2024 + - name: app.ebpf_dc_reference
2025 description: Count file access
2026 unit: "files"
2027 chart_type: stacked
2028 dimensions:
2021 - - name: a dimension per app group
2022 - - name: apps.dc_not_cache
2029 + - name: files
2030 + - name: app.ebpf_dc_not_cache
2031 description: Files not present inside directory cache
2032 unit: "files"
2033 chart_type: stacked
2034 dimensions:
2027 - - name: a dimension per app group
2028 - - name: apps.dc_not_found
2035 + - name: files
2036 + - name: app.ebpf_dc_not_found
2037 description: Files not found
2038 unit: "files"
2039 chart_type: stacked
2040 dimensions:
2033 - - name: a dimension per app group
2041 + - name: files
2042 - name: filesystem
2043 description: "These metrics show total number of calls to functions inside kernel."
2044 labels: []
@@ -2409,81 +2417,83 @@ modules:
2417 labels: []
2418 metrics:
2419 - name: cgroup.shmget
2412 - description: Calls to syscall <code>shmget(2)</code>.
2420 + description: Calls to syscall shmget(2).
2421 unit: "calls/s"
2422 chart_type: line
2423 dimensions:
2424 - name: get
2425 - name: cgroup.shmat
2418 - description: Calls to syscall <code>shmat(2)</code>.
2426 + description: Calls to syscall shmat(2).
2427 unit: "calls/s"
2428 chart_type: line
2429 dimensions:
2430 - name: at
2431 - name: cgroup.shmdt
2424 - description: Calls to syscall <code>shmdt(2)</code>.
2432 + description: Calls to syscall shmdt(2).
2433 unit: "calls/s"
2434 chart_type: line
2435 dimensions:
2436 - name: dt
2437 - name: cgroup.shmctl
2430 - description: Calls to syscall <code>shmctl(2)</code>.
2438 + description: Calls to syscall shmctl(2).
2439 unit: "calls/s"
2440 chart_type: line
2441 dimensions:
2442 - name: ctl
2443 - name: services.shmget
2436 - description: Calls to syscall <code>shmget(2)</code>.
2444 + description: Calls to syscall shmget(2).
2445 unit: "calls/s"
2446 chart_type: stacked
2447 dimensions:
2448 - name: a dimension per systemd service
2449 - name: services.shmat
2442 - description: Calls to syscall <code>shmat(2)</code>.
2450 + description: Calls to syscall shmat(2).
2451 unit: "calls/s"
2452 chart_type: stacked
2453 dimensions:
2454 - name: a dimension per systemd service
2455 - name: services.shmdt
2448 - description: Calls to syscall <code>shmdt(2)</code>.
2456 + description: Calls to syscall shmdt(2).
2457 unit: "calls/s"
2458 chart_type: stacked
2459 dimensions:
2460 - name: a dimension per systemd service
2461 - name: services.shmctl
2454 - description: Calls to syscall <code>shmctl(2)</code>.
2462 + description: Calls to syscall shmctl(2).
2463 unit: "calls/s"
2464 chart_type: stacked
2465 dimensions:
2466 - name: a dimension per systemd service
2467 - name: apps
2468 description: "These Metrics show grouped information per apps group."
2461 - labels: []
2469 + labels:
2470 + - name: app_group
2471 + description: The name of the group defined in the configuration.
2472 metrics:
2463 - - name: apps.shmget_call
2464 - description: Calls to syscall <code>shmget(2)</code>.
2473 + - name: app.ebpf_shmget_call
2474 + description: Calls to syscall shmget(2).
2475 unit: "calls/s"
2476 chart_type: stacked
2477 dimensions:
2468 - - name: a dimension per app group
2469 - - name: apps.shmat_call
2470 - description: Calls to syscall <code>shmat(2)</code>.
2478 + - name: calls
2479 + - name: app.ebpf_shmat_call
2480 + description: Calls to syscall shmat(2).
2481 unit: "calls/s"
2482 chart_type: stacked
2483 dimensions:
2474 - - name: a dimension per app group
2475 - - name: apps.shmdt_call
2476 - description: Calls to syscall <code>shmdt(2)</code>.
2484 + - name: calls
2485 + - name: app.ebpf_shmdt_call
2486 + description: Calls to syscall shmdt(2).
2487 unit: "calls/s"
2488 chart_type: stacked
2489 dimensions:
2480 - - name: a dimension per app group
2481 - - name: apps.shmctl_call
2482 - description: Calls to syscall <code>shmctl(2)</code>.
2490 + - name: calls
2491 + - name: app.ebpf_shmctl_call
2492 + description: Calls to syscall shmctl(2).
2493 unit: "calls/s"
2494 chart_type: stacked
2495 dimensions:
2486 - - name: a dimension per app group
2496 + - name: calls
2497 - name: global
2498 description: "These Metrics show number of calls for specified syscall."
2499 labels: []
@@ -2898,7 +2908,7 @@ modules:
2908 dimensions:
2909 - name: read
2910 - name: cgroup.vfs_fsync
2901 - description: Calls for <code>vfs_fsync</code>
2911 + description: Calls to vfs_fsync.
2912 unit: "calls/s"
2913 chart_type: line
2914 dimensions:
@@ -2910,7 +2920,7 @@ modules:
2920 dimensions:
2921 - name: fsync
2922 - name: cgroup.vfs_open
2913 - description: Calls for <code>vfs_open</code>
2923 + description: Calls to vfs_open.
2924 unit: "calls/s"
2925 chart_type: line
2926 dimensions:
@@ -2922,7 +2932,7 @@ modules:
2932 dimensions:
2933 - name: open
2934 - name: cgroup.vfs_create
2925 - description: Calls for <code>vfs_create</code>
2935 + description: Calls to vfs_create.
2936 unit: "calls/s"
2937 chart_type: line
2938 dimensions:
@@ -2976,7 +2986,7 @@ modules:
2986 dimensions:
2987 - name: a dimension per systemd service
2988 - name: services.vfs_fsync
2979 - description: Calls to <code>vfs_fsync</code>
2989 + description: Calls to vfs_fsync.
2990 unit: "calls/s"
2991 chart_type: stacked
2992 dimensions:
@@ -2988,7 +2998,7 @@ modules:
2998 dimensions:
2999 - name: a dimension per systemd service
3000 - name: services.vfs_open
2991 - description: Calls to <code>vfs_open</code>
3001 + description: Calls to vfs_open.
3002 unit: "calls/s"
3003 chart_type: stacked
3004 dimensions:
@@ -3000,7 +3010,7 @@ modules:
3010 dimensions:
3011 - name: a dimension per systemd service
3012 - name: services.vfs_create
3003 - description: Calls to <code>vfs_create</code>
3013 + description: Calls to vfs_create.
3014 unit: "calls/s"
3015 chart_type: stacked
3016 dimensions:
@@ -3043,7 +3053,7 @@ modules:
3053 - name: read
3054 - name: write
3055 - name: filesystem.vfs_fsync
3046 - description: Calls for <code>vfs_fsync</code>
3056 + description: Calls to vfs_fsync.
3057 unit: "calls/s"
3058 chart_type: line
3059 dimensions:
@@ -3055,7 +3065,7 @@ modules:
3065 dimensions:
3066 - name: fsync
3067 - name: filesystem.vfs_open
3058 - description: Calls for <code>vfs_open</code>
3068 + description: Calls to vfs_open.
3069 unit: "calls/s"
3070 chart_type: line
3071 dimensions:
@@ -3067,7 +3077,7 @@ modules:
3077 dimensions:
3078 - name: open
3079 - name: filesystem.vfs_create
3070 - description: Calls for <code>vfs_create</code>
3080 + description: Calls to vfs_create.
3081 unit: "calls/s"
3082 chart_type: line
3083 dimensions:
@@ -3080,86 +3090,88 @@ modules:
3090 - name: create
3091 - name: apps
3092 description: "These Metrics show grouped information per apps group."
3083 - labels: []
3093 + labels:
3094 + - name: app_group
3095 + description: The name of the group defined in the configuration.
3096 metrics:
3085 - - name: apps.file_deleted
3097 + - name: app.ebpf_call_vfs_unlink
3098 description: Files deleted
3099 unit: "calls/s"
3100 chart_type: stacked
3101 dimensions:
3090 - - name: a dimension per app group
3091 - - name: apps.vfs_write_call
3102 + - name: calls
3103 + - name: app.ebpf_call_vfs_write
3104 description: Write to disk
3105 unit: "calls/s"
3106 chart_type: stacked
3107 dimensions:
3096 - - name: a dimension per app group
3097 - - name: apps.vfs_write_error
3108 + - name: calls
3109 + - name: app.ebpf_call_vfs_write_error
3110 description: Fails to write
3111 unit: "calls/s"
3112 chart_type: stacked
3113 dimensions:
3102 - - name: a dimension per app group
3103 - - name: apps.vfs_read_call
3114 + - name: calls
3115 + - name: app.ebpf_call_vfs_read
3116 description: Read from disk
3117 unit: "calls/s"
3118 chart_type: stacked
3119 dimensions:
3108 - - name: a dimension per app group
3109 - - name: apps.vfs_read_error
3120 + - name: calls
3121 + - name: app.ebpf_call_vfs_read_error
3122 description: Fails to read
3123 unit: "calls/s"
3124 chart_type: stacked
3125 dimensions:
3114 - - name: a dimension per app group
3115 - - name: apps.vfs_write_bytes
3126 + - name: calls
3127 + - name: app.ebpf_call_vfs_write_bytes
3128 description: Bytes written on disk
3129 unit: "bytes/s"
3130 chart_type: stacked
3131 dimensions:
3120 - - name: a dimension per app group
3121 - - name: apps.vfs_read_bytes
3132 + - name: writes
3133 + - name: app.ebpf_call_vfs_read_bytes
3134 description: Bytes read on disk
3135 unit: "bytes/s"
3136 chart_type: stacked
3137 dimensions:
3126 - - name: a dimension per app group
3127 - - name: apps.vfs_fsync
3128 - description: Calls for <code>vfs_fsync</code>
3138 + - name: reads
3139 + - name: app.ebpf_call_vfs_fsync
3140 + description: Calls to vfs_fsync.
3141 unit: "calls/s"
3142 chart_type: stacked
3143 dimensions:
3132 - - name: a dimension per app group
3133 - - name: apps.vfs_fsync_error
3144 + - name: calls
3145 + - name: app.ebpf_call_vfs_fsync_error
3146 description: Sync error
3147 unit: "calls/s"
3148 chart_type: stacked
3149 dimensions:
3138 - - name: a dimension per app group
3139 - - name: apps.vfs_open
3140 - description: Calls for <code>vfs_open</code>
3150 + - name: calls
3151 + - name: app.ebpf_call_vfs_open
3152 + description: Calls to vfs_open.
3153 unit: "calls/s"
3154 chart_type: stacked
3155 dimensions:
3144 - - name: a dimension per app group
3145 - - name: apps.vfs_open_error
3156 + - name: calls
3157 + - name: app.ebpf_call_vfs_open_error
3158 description: Open error
3159 unit: "calls/s"
3160 chart_type: stacked
3161 dimensions:
3150 - - name: a dimension per app group
3151 - - name: apps.vfs_create
3152 - description: Calls for <code>vfs_create</code>
3162 + - name: calls
3163 + - name: app.ebpf_call_vfs_create
3164 + description: Calls to vfs_create.
3165 unit: "calls/s"
3166 chart_type: stacked
3167 dimensions:
3156 - - name: a dimension per app group
3157 - - name: apps.vfs_create_error
3168 + - name: calls
3169 + - name: app.ebpf_call_vfs_create_error
3170 description: Create error
3171 unit: "calls/s"
3172 chart_type: stacked
3173 dimensions:
3162 - - name: a dimension per app group
3174 + - name: calls
3175 - meta:
3176 plugin_name: ebpf.plugin
3177 module_name: process