add rrddim_get_last_stored_value to simplify function code in internal collectors (#16348)
Ilya Mashchenko committed
Nov 7, 2023 at 13:53 UTC
10238fc52aba2a200aade43ebfd1b4a9c29e6a3c
5 files changed
+79
-193
collectors/cgroups.plugin/cgroup-top.c
+20
-45
@@ -122,6 +122,8 @@ int cgroup_function_cgroup_top(BUFFER *wb, int timeout __maybe_unused, const cha
122
double max_net_received = 0.0;
123
double max_net_sent = 0.0;
124
125
+ RRDDIM *rd = NULL;
126
+
127
uv_mutex_lock(&cgroup_root_mutex);
128
129
for(struct cgroup *cg = cgroup_root; cg ; cg = cg->next) {
@@ -142,32 +144,13 @@ int cgroup_function_cgroup_top(BUFFER *wb, int timeout __maybe_unused, const cha
144
cpu = cg->st_cpu_rd_user->collector.last_stored_value + cg->st_cpu_rd_system->collector.last_stored_value;
145
max_cpu = MAX(max_cpu, cpu);
146
}
145
- buffer_json_add_array_item_double(wb, cpu);
146
-
147
- double ram = NAN;
148
- if (cg->st_mem_rd_ram) {
149
- ram = cg->st_mem_rd_ram->collector.last_stored_value;
150
- max_ram = MAX(max_ram, ram);
151
- }
152
- buffer_json_add_array_item_double(wb, ram);
153
-
154
- double disk_io_read = NAN;
155
- double disk_io_written = NAN;
156
- if (cg->st_throttle_io_rd_read) {
157
- disk_io_read = (cg->st_throttle_io_rd_read->collector.last_stored_value / 1024.0);
158
- disk_io_written = (ABS(cg->st_throttle_io_rd_written->collector.last_stored_value) / 1024.0);
159
- } else if (cg->st_io_rd_read) {
160
- disk_io_read = (cg->st_io_rd_read->collector.last_stored_value / 1024.0);
161
- disk_io_written = (ABS(cg->st_io_rd_written->collector.last_stored_value) / 1024.0);
162
- }
147
164
- if (!isnan(disk_io_read) && !isnan(disk_io_written)) {
165
- max_disk_io_read = MAX(max_disk_io_read, disk_io_read);
166
- max_disk_io_written = MAX(max_disk_io_written, disk_io_written);
167
- }
148
+ double ram = rrddim_get_last_stored_value(cg->st_mem_rd_ram, &max_ram, 1.0);
149
169
- buffer_json_add_array_item_double(wb, disk_io_read);
170
- buffer_json_add_array_item_double(wb, disk_io_written);
150
+ rd = cg->st_throttle_io_rd_read ? cg->st_throttle_io_rd_read : cg->st_io_rd_read;
151
+ double disk_io_read = rrddim_get_last_stored_value(rd, &max_disk_io_read, 1024.0);
152
+ rd = cg->st_throttle_io_rd_written ? cg->st_throttle_io_rd_written : cg->st_io_rd_written;
153
+ double disk_io_written = rrddim_get_last_stored_value(rd, &max_disk_io_written, 1024.0);
154
155
156
NETDATA_DOUBLE received, sent;
@@ -179,6 +162,10 @@ int cgroup_function_cgroup_top(BUFFER *wb, int timeout __maybe_unused, const cha
162
max_net_sent = MAX(max_net_sent, sent);
163
}
164
165
+ buffer_json_add_array_item_double(wb, cpu);
166
+ buffer_json_add_array_item_double(wb, ram);
167
+ buffer_json_add_array_item_double(wb, disk_io_read);
168
+ buffer_json_add_array_item_double(wb, disk_io_written);
169
buffer_json_add_array_item_double(wb, received);
170
buffer_json_add_array_item_double(wb, sent);
171
@@ -367,6 +354,8 @@ int cgroup_function_systemd_top(BUFFER *wb, int timeout __maybe_unused, const ch
354
double max_disk_io_read = 0.0;
355
double max_disk_io_written = 0.0;
356
357
+ RRDDIM *rd = NULL;
358
+
359
uv_mutex_lock(&cgroup_root_mutex);
360
361
for(struct cgroup *cg = cgroup_root; cg ; cg = cg->next) {
@@ -382,30 +371,16 @@ int cgroup_function_systemd_top(BUFFER *wb, int timeout __maybe_unused, const ch
371
cpu = cg->st_cpu_rd_user->collector.last_stored_value + cg->st_cpu_rd_system->collector.last_stored_value;
372
max_cpu = MAX(max_cpu, cpu);
373
}
385
- buffer_json_add_array_item_double(wb, cpu);
374
387
- double ram = NAN;
388
- if (cg->st_mem_rd_ram) {
389
- ram = cg->st_mem_rd_ram->collector.last_stored_value;
390
- max_ram = MAX(max_ram, ram);
391
- }
392
- buffer_json_add_array_item_double(wb, ram);
375
+ double ram = rrddim_get_last_stored_value(cg->st_mem_rd_ram, &max_ram, 1.0);
376
394
- double disk_io_read = NAN;
395
- double disk_io_written = NAN;
396
- if (cg->st_throttle_io_rd_read) {
397
- disk_io_read = (cg->st_throttle_io_rd_read->collector.last_stored_value / 1024.0);
398
- disk_io_written = (ABS(cg->st_throttle_io_rd_written->collector.last_stored_value) / 1024.0);
399
- } else if (cg->st_io_rd_read) {
400
- disk_io_read = (cg->st_io_rd_read->collector.last_stored_value / 1024.0);
401
- disk_io_written = (ABS(cg->st_io_rd_written->collector.last_stored_value) / 1024.0);
402
- }
403
-
404
- if (!isnan(disk_io_read) && !isnan(disk_io_written)) {
405
- max_disk_io_read = MAX(max_disk_io_read, disk_io_read);
406
- max_disk_io_written = MAX(max_disk_io_written, disk_io_written);
407
- }
377
+ rd = cg->st_throttle_io_rd_read ? cg->st_throttle_io_rd_read : cg->st_io_rd_read;
378
+ double disk_io_read = rrddim_get_last_stored_value(rd, &max_disk_io_read, 1024.0);
379
+ rd = cg->st_throttle_io_rd_written ? cg->st_throttle_io_rd_written : cg->st_io_rd_written;
380
+ double disk_io_written = rrddim_get_last_stored_value(rd, &max_disk_io_written, 1024.0);
381
382
+ buffer_json_add_array_item_double(wb, cpu);
383
+ buffer_json_add_array_item_double(wb, ram);
384
buffer_json_add_array_item_double(wb, disk_io_read);
385
buffer_json_add_array_item_double(wb, disk_io_written);
386
collectors/diskspace.plugin/plugin_diskspace.c
+6
-22
@@ -630,22 +630,6 @@ static void diskspace_main_cleanup(void *ptr) {
630
#error WORKER_UTILIZATION_MAX_JOB_TYPES has to be at least 3
631
#endif
632
633
-static double get_last_stored_value(RRDDIM *rd_dim, double *max_value, double mul, double div) {
634
- if (!rd_dim)
635
- return NAN;
636
-
637
- if (isnan(mul) || mul == 0)
638
- mul = 1.0;
639
- if (isnan(div) || div == 0)
640
- div = 1.0;
641
-
642
- double value = rd_dim->collector.last_stored_value * mul / div;
643
- value = ABS(value);
644
- *max_value = MAX(*max_value, value);
645
-
646
- return value;
647
-}
648
-
633
int diskspace_function_mount_points(BUFFER *wb, int timeout __maybe_unused, const char *function __maybe_unused,
634
void *collector_data __maybe_unused,
635
rrd_function_result_callback_t result_cb, void *result_cb_data,
@@ -685,12 +669,12 @@ int diskspace_function_mount_points(BUFFER *wb, int timeout __maybe_unused, cons
669
buffer_json_add_array_item_string(wb, string2str(mp->filesystem));
670
buffer_json_add_array_item_string(wb, string2str(mp->mountroot));
671
688
- double space_avail = get_last_stored_value(mp->rd_space_avail, &max_space_avail, 1.0, 1.0);
689
- double space_used = get_last_stored_value(mp->rd_space_used, &max_space_used, 1.0, 1.0);
690
- double space_reserved = get_last_stored_value(mp->rd_space_reserved, &max_space_reserved, 1.0, 1.0);
691
- double inodes_avail = get_last_stored_value(mp->rd_space_avail, &max_space_avail, 1.0, 1.0);
692
- double inodes_used = get_last_stored_value(mp->rd_space_used, &max_space_used, 1.0, 1.0);
693
- double inodes_reserved = get_last_stored_value(mp->rd_space_reserved, &max_space_reserved, 1.0, 1.0);
672
+ double space_avail = rrddim_get_last_stored_value(mp->rd_space_avail, &max_space_avail, 1.0);
673
+ double space_used = rrddim_get_last_stored_value(mp->rd_space_used, &max_space_used, 1.0);
674
+ double space_reserved = rrddim_get_last_stored_value(mp->rd_space_reserved, &max_space_reserved, 1.0);
675
+ double inodes_avail = rrddim_get_last_stored_value(mp->rd_inodes_avail, &max_inodes_avail, 1.0);
676
+ double inodes_used = rrddim_get_last_stored_value(mp->rd_inodes_used, &max_inodes_used, 1.0);
677
+ double inodes_reserved = rrddim_get_last_stored_value(mp->rd_inodes_reserved, &max_inodes_reserved, 1.0);
678
679
double space_util = NAN;
680
if (!isnan(space_avail) && !isnan(space_used)) {
collectors/proc.plugin/proc_diskstats.c
+22
-80
@@ -1054,102 +1054,44 @@ static int diskstats_function_block_devices(BUFFER *wb, int timeout __maybe_unus
1054
buffer_json_add_array_item_string(wb, d->serial);
1055
1056
// IO
1057
- double io_reads = NAN;
1058
- if (d->rd_io_reads) {
1059
- io_reads = d->rd_io_reads->collector.last_stored_value / 1024.0;
1060
- max_io_reads = MAX(max_io_reads, io_reads);
1061
- }
1062
- buffer_json_add_array_item_double(wb, io_reads);
1063
-
1064
- double io_writes = NAN;
1065
- if (d->rd_io_writes) {
1066
- io_writes = ABS(d->rd_io_writes->collector.last_stored_value / 1024.0);
1067
- max_io_writes = MAX(max_io_writes, io_writes);
1068
- }
1069
- buffer_json_add_array_item_double(wb, io_writes);
1070
-
1057
+ double io_reads = rrddim_get_last_stored_value(d->rd_io_reads, &max_io_reads, 1024.0);
1058
+ double io_writes = rrddim_get_last_stored_value(d->rd_io_writes, &max_io_writes, 1024.0);
1059
double io_total = NAN;
1060
if (!isnan(io_reads) && !isnan(io_writes)) {
1061
io_total = io_reads + io_writes;
1062
max_io = MAX(max_io, io_total);
1063
}
1076
- buffer_json_add_array_item_double(wb, io_total);
1077
-
1064
// Backlog and Busy Time
1079
- double busy_perc = NAN;
1080
- if (d->rd_util_utilization) {
1081
- busy_perc = d->rd_util_utilization->collector.last_stored_value;
1082
- max_busy_perc = MAX(max_busy_perc, busy_perc);
1083
- }
1065
+ double busy_perc = rrddim_get_last_stored_value(d->rd_util_utilization, &max_busy_perc, 1);
1066
+ double busy_time = rrddim_get_last_stored_value(d->rd_busy_busy, &max_busy_time, 1);
1067
+ double backlog_time = rrddim_get_last_stored_value(d->rd_backlog_backlog, &max_backlog_time, 1);
1068
+ // IOPS
1069
+ double iops_reads = rrddim_get_last_stored_value(d->rd_ops_reads, &max_iops_reads, 1);
1070
+ double iops_writes = rrddim_get_last_stored_value(d->rd_ops_writes, &max_iops_writes, 1);
1071
+ // IO Time
1072
+ double iops_time_reads = rrddim_get_last_stored_value(d->rd_iotime_reads, &max_iops_time_reads, 1);
1073
+ double iops_time_writes = rrddim_get_last_stored_value(d->rd_iotime_writes, &max_iops_time_writes, 1);
1074
+ // Avg IO Time
1075
+ double iops_avg_time_read = rrddim_get_last_stored_value(d->rd_await_reads, &max_iops_avg_time_read, 1);
1076
+ double iops_avg_time_write = rrddim_get_last_stored_value(d->rd_await_writes, &max_iops_avg_time_write, 1);
1077
+ // Avg IO Size
1078
+ double iops_avg_size_read = rrddim_get_last_stored_value(d->rd_avgsz_reads, &max_iops_avg_size_read, 1);
1079
+ double iops_avg_size_write = rrddim_get_last_stored_value(d->rd_avgsz_writes, &max_iops_avg_size_write, 1);
1080
+
1081
+
1082
+ buffer_json_add_array_item_double(wb, io_reads);
1083
+ buffer_json_add_array_item_double(wb, io_writes);
1084
+ buffer_json_add_array_item_double(wb, io_total);
1085
buffer_json_add_array_item_double(wb, busy_perc);
1085
- double busy_time = NAN;
1086
- if (d->rd_busy_busy) {
1087
- busy_time = d->rd_busy_busy->collector.last_stored_value;
1088
- max_busy_time = MAX(max_busy_time, busy_time);
1089
- }
1086
buffer_json_add_array_item_double(wb, busy_time);
1091
- double backlog_time = NAN;
1092
- if (d->rd_backlog_backlog) {
1093
- backlog_time = d->rd_backlog_backlog->collector.last_stored_value;
1094
- max_backlog_time = MAX(max_backlog_time, backlog_time);
1095
- }
1087
buffer_json_add_array_item_double(wb, backlog_time);
1097
-
1098
- // IOPS
1099
- double iops_reads = NAN;
1100
- if (d->rd_ops_reads) {
1101
- iops_reads = d->rd_ops_reads->collector.last_stored_value;
1102
- max_iops_reads = MAX(max_iops_reads, iops_reads);
1103
- }
1088
buffer_json_add_array_item_double(wb, iops_reads);
1105
- double iops_writes = NAN;
1106
- if (d->rd_ops_writes) {
1107
- iops_writes = ABS(d->rd_ops_writes->collector.last_stored_value);
1108
- max_iops_writes = MAX(max_iops_writes, iops_writes);
1109
- }
1089
buffer_json_add_array_item_double(wb, iops_writes);
1111
-
1112
- // IO Time
1113
- double iops_time_reads = NAN;
1114
- if (d->rd_iotime_reads) {
1115
- iops_time_reads = d->rd_iotime_reads->collector.last_stored_value;
1116
- max_iops_time_reads = MAX(max_iops_time_reads, iops_time_reads);
1117
- }
1090
buffer_json_add_array_item_double(wb, iops_time_reads);
1119
-
1120
- double iops_time_writes = NAN;
1121
- if (d->rd_iotime_writes) {
1122
- iops_time_writes = ABS(d->rd_iotime_writes->collector.last_stored_value);
1123
- max_iops_time_writes = MAX(max_iops_time_writes, iops_time_writes);
1124
- }
1091
buffer_json_add_array_item_double(wb, iops_time_writes);
1126
-
1127
- // Avg IO Time
1128
- double iops_avg_time_read = NAN;
1129
- if (d->rd_await_reads) {
1130
- iops_avg_time_read = d->rd_await_reads->collector.last_stored_value;
1131
- max_iops_avg_time_read = MAX(max_iops_avg_time_read, iops_avg_time_read);
1132
- }
1092
buffer_json_add_array_item_double(wb, iops_avg_time_read);
1134
- double iops_avg_time_write = NAN;
1135
- if (d->rd_await_writes) {
1136
- iops_avg_time_write = ABS(d->rd_await_writes->collector.last_stored_value);
1137
- max_iops_avg_time_write = MAX(max_iops_avg_time_write, iops_avg_time_write);
1138
- }
1093
buffer_json_add_array_item_double(wb, iops_avg_time_write);
1140
-
1141
- // Avg IO Size
1142
- double iops_avg_size_read = NAN;
1143
- if (d->rd_avgsz_reads) {
1144
- iops_avg_size_read = d->rd_avgsz_reads->collector.last_stored_value;
1145
- max_iops_avg_size_read = MAX(max_iops_avg_size_read, iops_avg_size_read);
1146
- }
1094
buffer_json_add_array_item_double(wb, iops_avg_size_read);
1148
- double iops_avg_size_write = NAN;
1149
- if (d->rd_avgsz_writes) {
1150
- iops_avg_size_write = ABS(d->rd_avgsz_writes->collector.last_stored_value);
1151
- max_iops_avg_size_write = MAX(max_iops_avg_size_write, iops_avg_size_write);
1152
- }
1095
buffer_json_add_array_item_double(wb, iops_avg_size_write);
1096
1097
// End
collectors/proc.plugin/proc_net_dev.c
+15
-46
@@ -658,18 +658,21 @@ int netdev_function_net_interfaces(BUFFER *wb, int timeout __maybe_unused, const
658
buffer_json_add_array_item_double(wb, d->mtu > 0 ? d->mtu : NAN);
659
660
rd = d->flipped ? d->rd_tbytes : d->rd_rbytes;
661
- double traffic_rx = NAN;
662
- if (rd) {
663
- traffic_rx = rd->collector.last_stored_value / 1000.0;
664
- max_traffic_rx = MAX(max_traffic_rx, traffic_rx);
665
- }
666
-
661
+ double traffic_rx = rrddim_get_last_stored_value(rd, &max_traffic_rx, 1000.0);
662
rd = d->flipped ? d->rd_rbytes : d->rd_tbytes;
668
- double traffic_tx = NAN;
669
- if (rd) {
670
- traffic_tx = ABS(rd->collector.last_stored_value / 1000.0);
671
- max_traffic_tx = MAX(max_traffic_tx, traffic_tx);
672
- }
663
+ double traffic_tx = rrddim_get_last_stored_value(rd, &max_traffic_tx, 1000.0);
664
+
665
+ rd = d->flipped ? d->rd_tpackets : d->rd_rpackets;
666
+ double packets_rx = rrddim_get_last_stored_value(rd, &max_packets_rx, 1000.0);
667
+ rd = d->flipped ? d->rd_rpackets : d->rd_tpackets;
668
+ double packets_tx = rrddim_get_last_stored_value(rd, &max_packets_tx, 1000.0);
669
+
670
+ double mcast_rx = rrddim_get_last_stored_value(d->rd_rmulticast, &max_mcast_rx, 1000.0);
671
+
672
+ rd = d->flipped ? d->rd_tdrops : d->rd_rdrops;
673
+ double drops_rx = rrddim_get_last_stored_value(rd, &max_drops_rx, 1.0);
674
+ rd = d->flipped ? d->rd_rdrops : d->rd_tdrops;
675
+ double drops_tx = rrddim_get_last_stored_value(rd, &max_drops_tx, 1.0);
676
677
// FIXME: "traffic" (total) is needed only for default_sorting
678
// can be removed when default_sorting will accept multiple columns (sum)
@@ -679,48 +682,14 @@ int netdev_function_net_interfaces(BUFFER *wb, int timeout __maybe_unused, const
682
max_traffic = MAX(max_traffic, traffic);
683
}
684
685
+
686
buffer_json_add_array_item_double(wb, traffic_rx);
687
buffer_json_add_array_item_double(wb, traffic_tx);
688
buffer_json_add_array_item_double(wb, traffic);
685
-
686
- rd = d->flipped ? d->rd_tpackets : d->rd_rpackets;
687
- double packets_rx = NAN;
688
- if (rd) {
689
- packets_rx = rd->collector.last_stored_value / 1000.0;
690
- max_packets_rx = MAX(max_packets_rx, packets_rx);
691
- }
689
buffer_json_add_array_item_double(wb, packets_rx);
693
-
694
- rd = d->flipped ? d->rd_rpackets : d->rd_tpackets;
695
- double packets_tx = NAN;
696
- if (rd) {
697
- packets_tx = ABS(rd->collector.last_stored_value / 1000.0);
698
- max_packets_tx = MAX(max_packets_tx, packets_tx);
699
- }
690
buffer_json_add_array_item_double(wb, packets_tx);
701
-
702
- double mcast_rx = NAN;
703
- if (d->rd_rmulticast) {
704
- mcast_rx = ABS(d->rd_rmulticast->collector.last_stored_value / 1000.0);
705
- max_mcast_rx = MAX(max_mcast_rx, mcast_rx);
706
- }
691
buffer_json_add_array_item_double(wb, mcast_rx);
708
-
709
-
710
- rd = d->flipped ? d->rd_tdrops : d->rd_rdrops;
711
- double drops_rx = NAN;
712
- if (rd) {
713
- drops_rx = rd->collector.last_stored_value;
714
- max_drops_rx = MAX(max_drops_rx, drops_rx);
715
- }
692
buffer_json_add_array_item_double(wb, drops_rx);
717
-
718
- rd = d->flipped ? d->rd_rdrops : d->rd_tdrops;
719
- double drops_tx = NAN;
720
- if (rd) {
721
- drops_tx = ABS(rd->collector.last_stored_value);
722
- max_drops_tx = MAX(max_drops_tx, drops_tx);
723
- }
693
buffer_json_add_array_item_double(wb, drops_tx);
694
695
buffer_json_add_array_item_object(wb);
database/rrd.h
+16
@@ -1668,6 +1668,22 @@ void rrdset_pluginsd_receive_unslot_and_cleanup(RRDSET *st);
1668
void rrdset_pluginsd_receive_unslot(RRDSET *st);
1669
1670
// ----------------------------------------------------------------------------
1671
+static inline double rrddim_get_last_stored_value(RRDDIM *rd_dim, double *max_value, double div) {
1672
+ if (!rd_dim)
1673
+ return NAN;
1674
+
1675
+ if (isnan(div) || div == 0.0)
1676
+ div = 1.0;
1677
+
1678
+ double value = rd_dim->collector.last_stored_value / div;
1679
+ value = ABS(value);
1680
+
1681
+ *max_value = MAX(*max_value, value);
1682
+
1683
+ return value;
1684
+}
1685
+
1686
+//
1687
// RRD DB engine declarations
1688
1689
#ifdef ENABLE_DBENGINE