archive/netdata_netdata
0
0
Fork 0
mirror of https://github.com/netdata/netdata.git synced 2025-04-14 17:48:37 +00:00
Code Issues Projects Releases Wiki Activity
netdata_netdata/collectors/cgroups.plugin/cgroup-charts.c
Costa Tsaousis f466b8aef5
DYNCFG: dynamically configured alerts () 
* cleanup alerts

* fix references

* fix references

* fix references

* load alerts once and apply them to each node

* simplify health_create_alarm_entry()

* Compile without warnings with compiler flags:

   -Wall -Wextra -Wformat=2 -Wshadow -Wno-format-nonliteral -Winit-self

* code re-organization and cleanup

* generate patterns when applying prototypes; give unique dyncfg names to all alerts

* eval expressions keep the source and the parsed_as as STRING pointers

* renamed host to node in dyncfg ids

* renamed host to node in dyncfg ids

* add all cloud roles to the list of parsed X-Netdata-Role header and also default to member access level

* working functionality

* code re-organization: moved health event-loop to a new file, moved health globals to health.c

* rrdcalctemplate is removed; alert_cfg is removed; foreach dimension is removed; RRDCALCs are now instanciated only when they are linked to RRDSETs

* dyncfg alert prototypes initialization for alerts

* health dyncfg split to separate file

* cleanup not-needed code

* normalize matches between parsing and json

* also detect !* for disabled alerts

* dyncfg capability disabled

* Store alert config part1

* Add rrdlabels_common_count

* wip health variables lookup without indexes

* Improve rrdlabels_common_count by reusing rrdlabels_find_label_with_key_unsafe with an additional parameter

* working variables with runtime lookup

* working variables with runtime lookup

* delete rrddimvar and rrdfamily index

* remove rrdsetvar; now all variables are in RRDVARs inside hosts and charts

* added /api/v1/variable that resolves a variable the same way alerts do

* remove rrdcalc from eval

* remove debug code

* remove duplicate assignment

* Fix memory leak

* all alert variables are now handled by alert_variable_lookup() and EVAL is now independent of alerts

* hide all internal structures of EVAL

* Enable -Wformat flag

Signed-off-by: Tasos Katsoulas <tasos@netdata.cloud>

* Adjust binding for calculation, warning, critical

* Remove unused macro

* Update config hash id

* use the right info and summary in alerts log

* use synchronous queries for alerts

* Handle cases when config_hash_id is missing from health_log

* remove deadlock from health worker

* parsing to json payload for health alert prototypes

* cleaner parsing and avoiding memory leaks in case of duplicate members in json

* fix left-over rename of function

* Keep original lookup field to send to the cloud
Cleanup / rename function to store config
Remove unused DEFINEs, functions

* Use ac->lookup

* link jobs to the host when the template is registered; do not accept running a function without a host

* full dyncfg support for health alerts, except action TEST

* working dyncfg additions, updates, removals

* fixed missing source, wrong status updates

* add alerts by type, component, classification, recipient and module at the /api/v2/alerts endpoint

* fix dyncfg unittest

* rename functions

* generalize the json-c parser macros and move them to libnetdata

* report progress when enabling and disabling dyncfg templates

* moved rrdcalc and rrdvar to health

* update alarms

* added schema for alerts; separated alert_action_options from rrdr_options; restructured the json payload for alerts

* enable parsed json alerts; allow sending back accepted but disabled

* added format_version for alerts payload; enables/disables status now is also inheritted by the status of the rules; fixed variable names in json output

* remove the RRDHOST pointer from DYNCFG

* Fix command field submitted to the cloud

* do not send updates to creation requests, for DYNCFG jobs

---------

Signed-off-by: Tasos Katsoulas <tasos@netdata.cloud>
Co-authored-by: Stelios Fragkakis <52996999+stelfrag@users.noreply.github.com>
Co-authored-by: Tasos Katsoulas <tasos@netdata.cloud>
Co-authored-by: ilyam8 <ilya@netdata.cloud>
2024-01-23 20:20:41 +02:00

1526 lines
58 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-3.0-or-later
#include "cgroup-internals.h"
void update_cpu_utilization_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_cpu;
if (unlikely(!cg->st_cpu)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services CPU utilization (100%% = 1 core)";
context = "systemd.service.cpu.utilization";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD;
} else {
title = k8s_is_kubepod(cg) ? "CPU Usage (100%% = 1000 mCPU)" : "CPU Usage (100%% = 1 core)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.cpu" : "cgroup.cpu";
prio = cgroup_containers_chart_priority;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_cpu = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu",
NULL,
"cpu",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_STACKED);
rrdset_update_rrdlabels(chart, cg->chart_labels);
if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
cg->st_cpu_rd_user = rrddim_add(chart, "user", NULL, 100, system_hz, RRD_ALGORITHM_INCREMENTAL);
cg->st_cpu_rd_system = rrddim_add(chart, "system", NULL, 100, system_hz, RRD_ALGORITHM_INCREMENTAL);
} else {
cg->st_cpu_rd_user = rrddim_add(chart, "user", NULL, 100, 1000000, RRD_ALGORITHM_INCREMENTAL);
cg->st_cpu_rd_system = rrddim_add(chart, "system", NULL, 100, 1000000, RRD_ALGORITHM_INCREMENTAL);
}
}
rrddim_set_by_pointer(chart, cg->st_cpu_rd_user, (collected_number)cg->cpuacct_stat.user);
rrddim_set_by_pointer(chart, cg->st_cpu_rd_system, (collected_number)cg->cpuacct_stat.system);
rrdset_done(chart);
}
void update_cpu_utilization_limit_chart(struct cgroup *cg, NETDATA_DOUBLE cpu_limit) {
if (is_cgroup_systemd_service(cg))
return;
RRDSET *chart = cg->st_cpu_limit;
if (unlikely(!cg->st_cpu_limit)) {
char *title = "CPU Usage within the limits";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_limit" : "cgroup.cpu_limit";
int prio = cgroup_containers_chart_priority - 1;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_cpu_limit = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_limit",
NULL,
"cpu",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED))
rrddim_add(chart, "used", NULL, 1, system_hz, RRD_ALGORITHM_ABSOLUTE);
else
rrddim_add(chart, "used", NULL, 1, 1000000, RRD_ALGORITHM_ABSOLUTE);
cg->prev_cpu_usage = (NETDATA_DOUBLE)(cg->cpuacct_stat.user + cg->cpuacct_stat.system) * 100;
}
NETDATA_DOUBLE cpu_usage = 0;
cpu_usage = (NETDATA_DOUBLE)(cg->cpuacct_stat.user + cg->cpuacct_stat.system) * 100;
NETDATA_DOUBLE cpu_used = 100 * (cpu_usage - cg->prev_cpu_usage) / (cpu_limit * cgroup_update_every);
rrdset_isnot_obsolete___safe_from_collector_thread(chart);
rrddim_set(chart, "used", (cpu_used > 0) ? (collected_number)cpu_used : 0);
cg->prev_cpu_usage = cpu_usage;
rrdvar_chart_variable_set(cg->st_cpu, cg->chart_var_cpu_limit, cpu_limit);
rrdset_done(chart);
}
void update_cpu_throttled_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
RRDSET *chart = cg->st_cpu_nr_throttled;
if (unlikely(!cg->st_cpu_nr_throttled)) {
char *title = "CPU Throttled Runnable Periods";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.throttled" : "cgroup.throttled";
int prio = cgroup_containers_chart_priority + 10;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_cpu_nr_throttled = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"throttled",
NULL,
"cpu",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "throttled", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set(chart, "throttled", (collected_number)cg->cpuacct_cpu_throttling.nr_throttled_perc);
rrdset_done(chart);
}
void update_cpu_throttled_duration_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
RRDSET *chart = cg->st_cpu_throttled_time;
if (unlikely(!cg->st_cpu_throttled_time)) {
char *title = "CPU Throttled Time Duration";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.throttled_duration" : "cgroup.throttled_duration";
int prio = cgroup_containers_chart_priority + 15;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_cpu_throttled_time = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"throttled_duration",
NULL,
"cpu",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "duration", NULL, 1, 1000000, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "duration", (collected_number)cg->cpuacct_cpu_throttling.throttled_time);
rrdset_done(chart);
}
void update_cpu_shares_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
RRDSET *chart = cg->st_cpu_shares;
if (unlikely(!cg->st_cpu_shares)) {
char *title = "CPU Time Relative Share";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_shares" : "cgroup.cpu_shares";
int prio = cgroup_containers_chart_priority + 20;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_cpu_shares = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_shares",
NULL,
"cpu",
context,
title,
"shares",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "shares", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set(chart, "shares", (collected_number)cg->cpuacct_cpu_shares.shares);
rrdset_done(chart);
}
void update_cpu_per_core_usage_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
char id[RRD_ID_LENGTH_MAX + 1];
unsigned int i;
if (unlikely(!cg->st_cpu_per_core)) {
char *title = k8s_is_kubepod(cg) ? "CPU Usage (100%% = 1000 mCPU) Per Core" : "CPU Usage (100%% = 1 core) Per Core";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_per_core" : "cgroup.cpu_per_core";
int prio = cgroup_containers_chart_priority + 100;
char buff[RRD_ID_LENGTH_MAX + 1];
cg->st_cpu_per_core = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_per_core",
NULL,
"cpu",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_STACKED);
rrdset_update_rrdlabels(cg->st_cpu_per_core, cg->chart_labels);
for (i = 0; i < cg->cpuacct_usage.cpus; i++) {
snprintfz(id, RRD_ID_LENGTH_MAX, "cpu%u", i);
rrddim_add(cg->st_cpu_per_core, id, NULL, 100, 1000000000, RRD_ALGORITHM_INCREMENTAL);
}
}
for (i = 0; i < cg->cpuacct_usage.cpus; i++) {
snprintfz(id, RRD_ID_LENGTH_MAX, "cpu%u", i);
rrddim_set(cg->st_cpu_per_core, id, (collected_number)cg->cpuacct_usage.cpu_percpu[i]);
}
rrdset_done(cg->st_cpu_per_core);
}
void update_mem_usage_detailed_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_mem;
if (unlikely(!cg->st_mem)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Memory";
context = "systemd.service.memory.ram.usage";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 15;
} else {
title = "Memory Usage";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.mem" : "cgroup.mem";
prio = cgroup_containers_chart_priority + 220;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_mem = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem",
NULL,
"mem",
context,
title,
"MiB",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_STACKED);
rrdset_update_rrdlabels(chart, cg->chart_labels);
if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
rrddim_add(chart, "cache", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "rss", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
if (cg->memory.detailed_has_swap)
rrddim_add(chart, "swap", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "rss_huge", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "mapped_file", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
} else {
rrddim_add(chart, "anon", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "kernel_stack", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "slab", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "sock", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "anon_thp", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "file", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
}
}
if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
rrddim_set(chart, "cache", (collected_number)cg->memory.total_cache);
collected_number rss = (collected_number)(cg->memory.total_rss - cg->memory.total_rss_huge);
if (rss < 0)
rss = 0;
rrddim_set(chart, "rss", rss);
if (cg->memory.detailed_has_swap)
rrddim_set(chart, "swap", (collected_number)cg->memory.total_swap);
rrddim_set(chart, "rss_huge", (collected_number)cg->memory.total_rss_huge);
rrddim_set(chart, "mapped_file", (collected_number)cg->memory.total_mapped_file);
} else {
rrddim_set(chart, "anon", (collected_number)cg->memory.anon);
rrddim_set(chart, "kernel_stack", (collected_number)cg->memory.kernel_stack);
rrddim_set(chart, "slab", (collected_number)cg->memory.slab);
rrddim_set(chart, "sock", (collected_number)cg->memory.sock);
rrddim_set(chart, "anon_thp", (collected_number)cg->memory.anon_thp);
rrddim_set(chart, "file", (collected_number)cg->memory.total_mapped_file);
}
rrdset_done(chart);
}
void update_mem_writeback_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_writeback;
if (unlikely(!cg->st_writeback)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Writeback Memory";
context = "systemd.service.memory.writeback";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 20;
} else {
title = "Writeback Memory";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.writeback" : "cgroup.writeback";
prio = cgroup_containers_chart_priority + 300;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_writeback = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"writeback",
NULL,
"mem",
context,
title,
"MiB",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_AREA);
rrdset_update_rrdlabels(chart, cg->chart_labels);
if (cg->memory.detailed_has_dirty)
rrddim_add(chart, "dirty", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "writeback", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
}
if (cg->memory.detailed_has_dirty)
rrddim_set(chart, "dirty", (collected_number)cg->memory.total_dirty);
rrddim_set(chart, "writeback", (collected_number)cg->memory.total_writeback);
rrdset_done(chart);
}
void update_mem_activity_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_mem_activity;
if (unlikely(!cg->st_mem_activity)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Memory Paging IO";
context = "systemd.service.memory.paging.io";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 30;
} else {
title = "Memory Activity";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.mem_activity" : "cgroup.mem_activity";
prio = cgroup_containers_chart_priority + 400;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_mem_activity = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_activity",
NULL,
"mem",
context,
title,
"MiB/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
// FIXME: systemd just in, out
rrddim_add(chart, "pgpgin", "in", system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(chart, "pgpgout", "out", -system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "pgpgin", (collected_number)cg->memory.total_pgpgin);
rrddim_set(chart, "pgpgout", (collected_number)cg->memory.total_pgpgout);
rrdset_done(chart);
}
void update_mem_pgfaults_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_pgfaults;
if (unlikely(!cg->st_pgfaults)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Memory Page Faults";
context = "systemd.service.memory.paging.faults";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 25;
} else {
title = "Memory Page Faults";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.pgfaults" : "cgroup.pgfaults";
prio = cgroup_containers_chart_priority + 500;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_pgfaults = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"pgfaults",
NULL,
"mem",
context,
title,
"MiB/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "pgfault", NULL, system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(chart, "pgmajfault", "swap", -system_page_size, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "pgfault", (collected_number)cg->memory.total_pgfault);
rrddim_set(chart, "pgmajfault", (collected_number)cg->memory.total_pgmajfault);
rrdset_done(chart);
}
void update_mem_usage_limit_chart(struct cgroup *cg, unsigned long long memory_limit) {
if (is_cgroup_systemd_service(cg))
return;
RRDSET *chart = cg->st_mem_usage_limit;
if (unlikely(!cg->st_mem_usage_limit)) {
char *title = "Used RAM within the limits";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.mem_usage_limit" : "cgroup.mem_usage_limit";
int prio = cgroup_containers_chart_priority + 200;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_mem_usage_limit = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_usage_limit",
NULL,
"mem",
context,
title,
"MiB",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_STACKED);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "available", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "used", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
}
rrdset_isnot_obsolete___safe_from_collector_thread(chart);
rrddim_set(chart, "available", (collected_number)(memory_limit - cg->memory.usage_in_bytes));
rrddim_set(chart, "used", (collected_number)cg->memory.usage_in_bytes);
rrdset_done(chart);
}
void update_mem_utilization_chart(struct cgroup *cg, unsigned long long memory_limit) {
if (is_cgroup_systemd_service(cg))
return;
RRDSET *chart = cg->st_mem_utilization;
if (unlikely(!cg->st_mem_utilization)) {
char *title = "Memory Utilization";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.mem_utilization" : "cgroup.mem_utilization";
int prio = cgroup_containers_chart_priority + 199;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_mem_utilization = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_utilization",
NULL,
"mem",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_AREA);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "utilization", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
rrdset_isnot_obsolete___safe_from_collector_thread(chart);
collected_number util = (collected_number)(cg->memory.usage_in_bytes * 100 / memory_limit);
rrddim_set(chart, "utilization", util);
rrdset_done(chart);
}
void update_mem_failcnt_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_mem_failcnt;
if (unlikely(!cg->st_mem_failcnt)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Memory Limit Failures";
context = "systemd.service.memory.failcnt";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 10;
} else {
title = "Memory Limit Failures";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.mem_failcnt" : "cgroup.mem_failcnt";
prio = cgroup_containers_chart_priority + 250;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_mem_failcnt = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_failcnt",
NULL,
"mem",
context,
title,
"count",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "failures", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "failures", (collected_number)cg->memory.failcnt);
rrdset_done(chart);
}
void update_mem_usage_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_mem_usage;
if (unlikely(!cg->st_mem_usage)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Used Memory";
context = "systemd.service.memory.usage";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 5;
} else {
title = "Used Memory";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.mem_usage" : "cgroup.mem_usage";
prio = cgroup_containers_chart_priority + 210;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_mem_usage = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_usage",
NULL,
"mem",
context,
title,
"MiB",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_STACKED);
rrdset_update_rrdlabels(chart, cg->chart_labels);
cg->st_mem_rd_ram = rrddim_add(chart, "ram", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
cg->st_mem_rd_swap = rrddim_add(chart, "swap", NULL, 1, 1024 * 1024, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, cg->st_mem_rd_ram, (collected_number)cg->memory.usage_in_bytes);
if (!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) {
rrddim_set_by_pointer(
chart,
cg->st_mem_rd_swap,
cg->memory.msw_usage_in_bytes > (cg->memory.usage_in_bytes + cg->memory.total_inactive_file) ?
(collected_number)(cg->memory.msw_usage_in_bytes -
(cg->memory.usage_in_bytes + cg->memory.total_inactive_file)) :
0);
} else {
rrddim_set_by_pointer(chart, cg->st_mem_rd_swap, (collected_number)cg->memory.msw_usage_in_bytes);
}
rrdset_done(chart);
}
void update_io_serviced_bytes_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_io;
if (unlikely(!cg->st_io)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Disk Read/Write Bandwidth";
context = "systemd.service.disk.io";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 35;
} else {
title = "I/O Bandwidth (all disks)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.io" : "cgroup.io";
prio = cgroup_containers_chart_priority + 1200;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_io = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"io",
NULL,
"disk",
context,
title,
"KiB/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_AREA);
rrdset_update_rrdlabels(chart, cg->chart_labels);
cg->st_io_rd_read = rrddim_add(chart, "read", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
cg->st_io_rd_written = rrddim_add(cg->st_io, "write", NULL, -1, 1024, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, cg->st_io_rd_read, (collected_number)cg->io_service_bytes.Read);
rrddim_set_by_pointer(chart, cg->st_io_rd_written, (collected_number)cg->io_service_bytes.Write);
rrdset_done(chart);
}
void update_io_serviced_ops_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_serviced_ops;
if (unlikely(!cg->st_serviced_ops)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Disk Read/Write Operations";
context = "systemd.service.disk.iops";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 40;
} else {
title = "Serviced I/O Operations (all disks)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.serviced_ops" : "cgroup.serviced_ops";
prio = cgroup_containers_chart_priority + 1200;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_serviced_ops = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"serviced_ops",
NULL,
"disk",
context,
title,
"operations/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(chart, "write", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "read", (collected_number)cg->io_serviced.Read);
rrddim_set(chart, "write", (collected_number)cg->io_serviced.Write);
rrdset_done(chart);
}
void update_throttle_io_serviced_bytes_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_throttle_io;
if (unlikely(!cg->st_throttle_io)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Throttle Disk Read/Write Bandwidth";
context = "systemd.service.disk.throttle.io";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 45;
} else {
title = "Throttle I/O Bandwidth (all disks)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.throttle_io" : "cgroup.throttle_io";
prio = cgroup_containers_chart_priority + 1200;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_throttle_io = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"throttle_io",
NULL,
"disk",
context,
title,
"KiB/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_AREA);
rrdset_update_rrdlabels(chart, cg->chart_labels);
cg->st_throttle_io_rd_read = rrddim_add(chart, "read", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
cg->st_throttle_io_rd_written = rrddim_add(chart, "write", NULL, -1, 1024, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, cg->st_throttle_io_rd_read, (collected_number)cg->throttle_io_service_bytes.Read);
rrddim_set_by_pointer(chart, cg->st_throttle_io_rd_written, (collected_number)cg->throttle_io_service_bytes.Write);
rrdset_done(chart);
}
void update_throttle_io_serviced_ops_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_throttle_serviced_ops;
if (unlikely(!cg->st_throttle_serviced_ops)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Throttle Disk Read/Write Operations";
context = "systemd.service.disk.throttle.iops";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 50;
} else {
title = "Throttle Serviced I/O Operations (all disks)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.throttle_serviced_ops" : "cgroup.throttle_serviced_ops";
prio = cgroup_containers_chart_priority + 1200;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_throttle_serviced_ops = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"throttle_serviced_ops",
NULL,
"disk",
context,
title,
"operations/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "read", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(chart, "write", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "read", (collected_number)cg->throttle_io_serviced.Read);
rrddim_set(chart, "write", (collected_number)cg->throttle_io_serviced.Write);
rrdset_done(chart);
}
void update_io_queued_ops_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_queued_ops;
if (unlikely(!cg->st_queued_ops)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Queued Disk Read/Write Operations";
context = "systemd.service.disk.queued_iops";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 55;
} else {
title = "Queued I/O Operations (all disks)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.queued_ops" : "cgroup.queued_ops";
prio = cgroup_containers_chart_priority + 2000;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_queued_ops = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"queued_ops",
NULL,
"disk",
context,
title,
"operations",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "read", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
rrddim_add(chart, "write", NULL, -1, 1, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set(chart, "read", (collected_number)cg->io_queued.Read);
rrddim_set(chart, "write", (collected_number)cg->io_queued.Write);
rrdset_done(chart);
}
void update_io_merged_ops_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_merged_ops;
if (unlikely(!cg->st_merged_ops)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Merged Disk Read/Write Operations";
context = "systemd.service.disk.merged_iops";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 60;
} else {
title = "Merged I/O Operations (all disks)";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.merged_ops" : "cgroup.merged_ops";
prio = cgroup_containers_chart_priority + 2100;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_merged_ops = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"merged_ops",
NULL,
"disk",
context,
title,
"operations/s",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
rrddim_add(chart, "read", NULL, 1, 1024, RRD_ALGORITHM_INCREMENTAL);
rrddim_add(chart, "write", NULL, -1, 1024, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set(chart, "read", (collected_number)cg->io_merged.Read);
rrddim_set(chart, "write", (collected_number)cg->io_merged.Write);
rrdset_done(chart);
}
void update_cpu_some_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->cpu_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "CPU some pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_some_pressure" : "cgroup.cpu_some_pressure";
int prio = cgroup_containers_chart_priority + 2200;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_some_pressure",
NULL,
"cpu",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "some 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "some 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "some 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_cpu_some_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->cpu_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "CPU some pressure stall time";
char *context =
k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_some_pressure_stall_time" : "cgroup.cpu_some_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2220;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_some_pressure_stall_time",
NULL,
"cpu",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_cpu_full_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->cpu_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "CPU full pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_full_pressure" : "cgroup.cpu_full_pressure";
int prio = cgroup_containers_chart_priority + 2240;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_full_pressure",
NULL,
"cpu",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "full 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "full 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "full 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_cpu_full_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->cpu_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "CPU full pressure stall time";
char *context =
k8s_is_kubepod(cg) ? "k8s.cgroup.cpu_full_pressure_stall_time" : "cgroup.cpu_full_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2260;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"cpu_full_pressure_stall_time",
NULL,
"cpu",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_mem_some_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->memory_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "Memory some pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.memory_some_pressure" : "cgroup.memory_some_pressure";
int prio = cgroup_containers_chart_priority + 2300;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_some_pressure",
NULL,
"mem",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "some 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "some 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "some 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_mem_some_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->memory_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "Memory some pressure stall time";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.memory_some_pressure_stall_time" :
"cgroup.memory_some_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2320;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"memory_some_pressure_stall_time",
NULL,
"mem",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_mem_full_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->memory_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "Memory full pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.memory_full_pressure" : "cgroup.memory_full_pressure";
int prio = cgroup_containers_chart_priority + 2340;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"mem_full_pressure",
NULL,
"mem",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "full 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "full 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "full 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_mem_full_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->memory_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "Memory full pressure stall time";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.memory_full_pressure_stall_time" :
"cgroup.memory_full_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2360;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"memory_full_pressure_stall_time",
NULL,
"mem",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_irq_some_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->irq_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "IRQ some pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.irq_some_pressure" : "cgroup.irq_some_pressure";
int prio = cgroup_containers_chart_priority + 2310;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"irq_some_pressure",
NULL,
"interrupts",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "some 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "some 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "some 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_irq_some_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->irq_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "IRQ some pressure stall time";
char *context =
k8s_is_kubepod(cg) ? "k8s.cgroup.irq_some_pressure_stall_time" : "cgroup.irq_some_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2330;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"irq_some_pressure_stall_time",
NULL,
"interrupts",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_irq_full_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->irq_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "IRQ full pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.irq_full_pressure" : "cgroup.irq_full_pressure";
int prio = cgroup_containers_chart_priority + 2350;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"irq_full_pressure",
NULL,
"interrupts",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "full 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "full 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "full 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_irq_full_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->irq_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "IRQ full pressure stall time";
char *context =
k8s_is_kubepod(cg) ? "k8s.cgroup.irq_full_pressure_stall_time" : "cgroup.irq_full_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2370;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"irq_full_pressure_stall_time",
NULL,
"interrupts",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_io_some_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->io_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "I/O some pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.io_some_pressure" : "cgroup.io_some_pressure";
int prio = cgroup_containers_chart_priority + 2400;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"io_some_pressure",
NULL,
"disk",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "some 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "some 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "some 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_io_some_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->io_pressure;
struct pressure_charts *pcs = &res->some;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "I/O some pressure stall time";
char *context =
k8s_is_kubepod(cg) ? "k8s.cgroup.io_some_pressure_stall_time" : "cgroup.io_some_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2420;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"io_some_pressure_stall_time",
NULL,
"disk",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_io_full_pressure_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->io_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->share_time.st;
if (unlikely(!pcs->share_time.st)) {
char *title = "I/O full pressure";
char *context = k8s_is_kubepod(cg) ? "k8s.cgroup.io_full_pressure" : "cgroup.io_full_pressure";
int prio = cgroup_containers_chart_priority + 2440;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->share_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"io_full_pressure",
NULL,
"disk",
context,
title,
"percentage",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->share_time.rd10 = rrddim_add(chart, "full 10", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd60 = rrddim_add(chart, "full 60", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
pcs->share_time.rd300 = rrddim_add(chart, "full 300", NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, pcs->share_time.rd10, (collected_number)(pcs->share_time.value10 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd60, (collected_number)(pcs->share_time.value60 * 100));
rrddim_set_by_pointer(chart, pcs->share_time.rd300, (collected_number)(pcs->share_time.value300 * 100));
rrdset_done(chart);
}
void update_io_full_pressure_stall_time_chart(struct cgroup *cg) {
if (is_cgroup_systemd_service(cg))
return;
struct pressure *res = &cg->io_pressure;
struct pressure_charts *pcs = &res->full;
RRDSET *chart = pcs->total_time.st;
if (unlikely(!pcs->total_time.st)) {
char *title = "I/O full pressure stall time";
char *context =
k8s_is_kubepod(cg) ? "k8s.cgroup.io_full_pressure_stall_time" : "cgroup.io_full_pressure_stall_time";
int prio = cgroup_containers_chart_priority + 2460;
char buff[RRD_ID_LENGTH_MAX + 1];
chart = pcs->total_time.st = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"io_full_pressure_stall_time",
NULL,
"disk",
context,
title,
"ms",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
pcs->total_time.rdtotal = rrddim_add(chart, "time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
}
rrddim_set_by_pointer(chart, pcs->total_time.rdtotal, (collected_number)(pcs->total_time.value_total));
rrdset_done(chart);
}
void update_pids_current_chart(struct cgroup *cg) {
RRDSET *chart = cg->st_pids;
if (unlikely(!cg->st_pids)) {
char *title;
char *context;
int prio;
if (is_cgroup_systemd_service(cg)) {
title = "Systemd Services Number of Processes";
context = "systemd.service.pids.current";
prio = NETDATA_CHART_PRIO_CGROUPS_SYSTEMD + 70;
} else {
title = "Number of processes";
context = k8s_is_kubepod(cg) ? "k8s.cgroup.pids_current" : "cgroup.pids_current";
prio = cgroup_containers_chart_priority + 2150;
}
char buff[RRD_ID_LENGTH_MAX + 1];
chart = cg->st_pids = rrdset_create_localhost(
cgroup_chart_type(buff, cg),
"pids_current",
NULL,
"pids",
context,
title,
"pids",
PLUGIN_CGROUPS_NAME,
is_cgroup_systemd_service(cg) ? PLUGIN_CGROUPS_MODULE_SYSTEMD_NAME : PLUGIN_CGROUPS_MODULE_CGROUPS_NAME,
prio,
cgroup_update_every,
RRDSET_TYPE_LINE);
rrdset_update_rrdlabels(chart, cg->chart_labels);
cg->st_pids_rd_pids_current = rrddim_add(chart, "pids", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
}
rrddim_set_by_pointer(chart, cg->st_pids_rd_pids_current, (collected_number)cg->pids.pids_current);
rrdset_done(chart);
}
Reference in a new issue View git blame Copy permalink