graphs: Add automatic field composition for objects

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/daemon/graphs/conntrack.c b/src/daemon/graphs/conntrack.c
index 9fe516d50b1bf1ee3df66c458354b81b11768936..ba8c16630b9b56abed4edd52ffa66c1aece6a306 100644 (file)
--- a/src/daemon/graphs/conntrack.c
+++ b/src/daemon/graphs/conntrack.c
@@ -39,7 +39,7 @@ static int conntrack_render(td_ctx* ctx,
        int r;
 
        // This requires the conntrack source
-       r = td_graph_require_source(graph, args, "conntrack", object);
+       r = td_graph_require_source(graph, args, "conntrack", NULL);
        if (r < 0)
                return r;
 
@@ -47,18 +47,20 @@ static int conntrack_render(td_ctx* ctx,
        PRINT_HEADER4(args, _("Current"), _("Average"), _("Minimum"), _("Maximum"));
 
        // Entries
-       DRAW_AREA_WITH_LABEL(args, "count", GREEN, _("Entries"));
-       PRINT_LARGE_INTEGER(args, "count_cur");
-       PRINT_LARGE_INTEGER(args, "count_avg");
-       PRINT_LARGE_INTEGER(args, "count_min");
-       PRINT_LARGE_INTEGER(args, "count_max", EOL);
+       DRAW_AREA_WITH_LABEL(args, "count", NULL, GREEN, _("Entries"));
+       PRINT_LARGE_INTEGER(args, FIELD_CURRENT("count"), NULL);
+       PRINT_LARGE_INTEGER(args, FIELD_AVERAGE("count"), NULL);
+       PRINT_LARGE_INTEGER(args, FIELD_MINIMUM("count"), NULL);
+       PRINT_LARGE_INTEGER(args, FIELD_MAXIMUM("count"), NULL);
+       PRINT_EOL(args);
 
        // Limit
-       DRAW_LINE1_WITH_LABEL(args, "max", LIMIT, _("Limit"), DASHES SKIPSCALE);
-       PRINT_LARGE_INTEGER(args, "max_cur");
+       DRAW_LINE1_WITH_LABEL(args, "max", NULL, LIMIT, _("Limit"), DASHES SKIPSCALE);
+       PRINT_LARGE_INTEGER(args, "max_cur", NULL);
        PRINT_NOTHING(args);
        PRINT_NOTHING(args);
-       PRINT_NOTHING(args, EOL);
+       PRINT_NOTHING(args);
+       PRINT_EOL(args);
 
        return 0;
 }

diff --git a/src/daemon/graphs/contextswitches.c b/src/daemon/graphs/contextswitches.c
index 52d94d557b361cfec3bc5db4ed8aaab31c035b1f..9f9570f77ebfa51fa65db15b6af3fd6220e77695 100644 (file)
--- a/src/daemon/graphs/contextswitches.c
+++ b/src/daemon/graphs/contextswitches.c
@@ -39,7 +39,7 @@ static int contextswitches_render(td_ctx* ctx,
        int r;
 
        // This requires the contextswitches source
-       r = td_graph_require_source(graph, args, "contextswitches", object);
+       r = td_graph_require_source(graph, args, "contextswitches", NULL);
        if (r < 0)
                return r;
 
@@ -47,11 +47,12 @@ static int contextswitches_render(td_ctx* ctx,
        PRINT_HEADER4(args, _("Current"), _("Average"), _("Minimum"), _("Maximum"));
 
        // Context Switches
-       DRAW_AREA_WITH_LABEL(args, "ctxt", GREEN, _("Context Switches"));
-       PRINT_LARGE_INTEGER(args, "ctxt_cur");
-       PRINT_LARGE_INTEGER(args, "ctxt_avg");
-       PRINT_LARGE_INTEGER(args, "ctxt_min");
-       PRINT_LARGE_INTEGER(args, "ctxt_max", EOL);
+       DRAW_AREA_WITH_LABEL(args, "ctxt", NULL, GREEN, _("Context Switches"));
+       PRINT_LARGE_INTEGER(args, FIELD_CURRENT("ctxt"), NULL);
+       PRINT_LARGE_INTEGER(args, FIELD_AVERAGE("ctxt"), NULL);
+       PRINT_LARGE_INTEGER(args, FIELD_MINIMUM("ctxt"), NULL);
+       PRINT_LARGE_INTEGER(args, FIELD_MAXIMUM("ctxt"), NULL);
+       PRINT_EOL(args);
 
        return 0;
 }

diff --git a/src/daemon/graphs/graph.h b/src/daemon/graphs/graph.h
index 6681e48d1cdf4ee1dc2e99ebd5288575391e216b..c5267cef2ae47175cf75f0498938d3cb5a83d012 100644 (file)
--- a/src/daemon/graphs/graph.h
+++ b/src/daemon/graphs/graph.h
@@ -58,33 +58,49 @@
 // Macro to terminate a line
 #define EOL                            "\\j"
 
+// Returns the string or an empty string
+#define CONSTANT_OR_EMPTY(s, constant)         (s) ? constant : ""
+#define MAYBE_EMPTY(s)                                         (s) ? s : ""
+
+// Format literal for the field name with an optional object
+#define FIELD                  "%s%s%s"
+#define FIELD_AND_OBJECT(field, object)                field, CONSTANT_OR_EMPTY(object, "_"), MAYBE_EMPTY(object)
+
 // Draw a LINE, AREA, etc.
-#define DRAW(args, what, field, color, ...) \
-       SCRIPT(args, what ":" field color __VA_ARGS__)
+#define DRAW(args, what, field, object, color, ...) \
+       SCRIPT(args, what ":" FIELD color __VA_ARGS__, FIELD_AND_OBJECT(field, object))
 
-#define DRAW_WITH_LABEL(args, what, field, color, label, ...) \
-       SCRIPT(args, what ":" field color ":" LABEL __VA_ARGS__, label)
+#define DRAW_WITH_LABEL(args, what, field, object, color, label, ...) \
+       SCRIPT(args, what ":" FIELD color ":" LABEL __VA_ARGS__, FIELD_AND_OBJECT(field, object), label)
 
 // Draw lines
-#define DRAW_LINE1(args, field, color, ...) DRAW(args, "LINE1", field, color, __VA_ARGS__)
-#define DRAW_LINE1_WITH_LABEL(args, field, color, label, ...) DRAW_WITH_LABEL(args, "LINE1", field, color, label, __VA_ARGS__)
-#define DRAW_LINE2(args, field, color, ...) DRAW(args, "LINE2", field, color, __VA_ARGS__)
-#define DRAW_LINE2_WITH_LABEL(args, field, color, label, ...) DRAW_WITH_LABEL(args, "LINE2", field, color, label, __VA_ARGS__)
-#define DRAW_LINE3(args, field, color, ...) DRAW(args, "LINE3", field, color, __VA_ARGS__)
-#define DRAW_LINE3_WITH_LABEL(args, field, color, label, ...) DRAW_WITH_LABEL(args, "LINE3", field, color, label, __VA_ARGS__)
+#define DRAW_LINE1(args, field, object, color, ...) \
+       DRAW(args, "LINE1", field, object, color, __VA_ARGS__)
+#define DRAW_LINE1_WITH_LABEL(args, field, object, color, label, ...) \
+       DRAW_WITH_LABEL(args, "LINE1", field, object, color, label, __VA_ARGS__)
+
+#define DRAW_LINE2(args, field, object, color, ...) \
+       DRAW(args, "LINE2", field, object, color, __VA_ARGS__)
+#define DRAW_LINE2_WITH_LABEL(args, field, object, color, label, ...) \
+       DRAW_WITH_LABEL(args, "LINE2", field, object, color, label, __VA_ARGS__)
+
+#define DRAW_LINE3(args, field, object, color, ...) \
+       DRAW(args, "LINE3", field, object, color, __VA_ARGS__)
+#define DRAW_LINE3_WITH_LABEL(args, field, object, color, label, ...) \
+       DRAW_WITH_LABEL(args, "LINE3", field, object, color, label, __VA_ARGS__)
 
 // Macros to draw the background of an area
-#define DRAW_AREA_BACKGROUND(args, field, color, ...) \
-       DRAW(args, "AREA", field, COLOR_WITH_ALPHA(color, OPACITY_AREA), __VA_ARGS__)
+#define DRAW_AREA_BACKGROUND(args, field, object, color, ...) \
+       DRAW(args, "AREA", field, object, COLOR_WITH_ALPHA(color, OPACITY_AREA), __VA_ARGS__)
 
 // Macros to draw the area's outline
 #define DRAW_AREA_OUTLINE_WITH_LABEL   DRAW_LINE1_WITH_LABEL
 
 // Areas are being drawn with an outline
-#define DRAW_AREA_WITH_LABEL(args, field, color, label, ...) \
+#define DRAW_AREA_WITH_LABEL(args, field, object, color, label, ...) \
        do { \
-               DRAW_AREA_BACKGROUND(args, field, color); \
-               DRAW_AREA_OUTLINE_WITH_LABEL(args, field, color, label, __VA_ARGS__); \
+               DRAW_AREA_BACKGROUND(args, field, object, color); \
+               DRAW_AREA_OUTLINE_WITH_LABEL(args, field, object, color, label, __VA_ARGS__); \
        } while(0)
 
 // Modifiers
@@ -95,17 +111,19 @@
 #define SKIPSCALE              ":skipscale"
 
 // Add something to the legend of the graph
-#define PRINT(args, field, ...)                                        SCRIPT(args, "GPRINT:" field ":" __VA_ARGS__)
-#define PRINT_EMPTY_LINE(args)                                 SCRIPT(args, "COMMENT: \\n")
-#define PRINT_HEADER(args, label, ...)                 SCRIPT(args, "COMMENT:" COLUMN __VA_ARGS__, label)
-#define PRINT_LABEL(args, label, ...)                  SCRIPT(args, "COMMENT: %-31s" __VA_ARGS__, label)
-#define PRINT_EMPTY_LABEL(args, ...)                   SCRIPT(args, "COMMENT:                                " __VA_ARGS__)
-#define PRINT_NOTHING(args, ...)                               SCRIPT(args, "COMMENT:                " __VA_ARGS__)
-#define PRINT_PERCENTAGE(args, field, ...)             PRINT(args, field, PERCENTAGE __VA_ARGS__)
-#define PRINT_INTEGER(args, field, ...)                        PRINT(args, field, INTEGER __VA_ARGS__)
-#define PRINT_LARGE_INTEGER(args, field, ...)  PRINT(args, field, LARGE_INTEGER __VA_ARGS__)
-#define PRINT_FLOAT(args, field, ...)                  PRINT(args, field, FLOAT __VA_ARGS__)
-#define PRINT_LARGE_FLOAT(args, field, ...)            PRINT(args, field, LARGE_FLOAT __VA_ARGS__)
+#define PRINT_EMPTY_LINE(args)                                                 SCRIPT(args, "COMMENT: \\n")
+#define PRINT_HEADER(args, label, ...)                                 SCRIPT(args, "COMMENT:" COLUMN __VA_ARGS__, label)
+#define PRINT_LABEL(args, label, ...)                                  SCRIPT(args, "COMMENT: %-31s" __VA_ARGS__, label)
+#define PRINT_EMPTY_LABEL(args, ...)                                   SCRIPT(args, "COMMENT:                                " __VA_ARGS__)
+#define PRINT_NOTHING(args, ...)                                               SCRIPT(args, "COMMENT:                " __VA_ARGS__)
+#define PRINT(args, field, object, format, ...) \
+       SCRIPT(args, "GPRINT:" FIELD ":" format, FIELD_AND_OBJECT(field, object) ##__VA_ARGS__)
+#define PRINT_PERCENTAGE(args, field, object, ...)             PRINT(args, field, object, PERCENTAGE, __VA_ARGS__)
+#define PRINT_INTEGER(args, field, object, ...)                        PRINT(args, field, object, INTEGER, __VA_ARGS__)
+#define PRINT_LARGE_INTEGER(args, field, object, ...)  PRINT(args, field, object, LARGE_INTEGER, __VA_ARGS__)
+#define PRINT_FLOAT(args, field, object, ...)                  PRINT(args, field, object, FLOAT, __VA_ARGS__)
+#define PRINT_LARGE_FLOAT(args, field, object, ...)            PRINT(args, field, object, LARGE_FLOAT, __VA_ARGS__)
+#define PRINT_EOL(args)                                                                        SCRIPT(args, "COMMENT:" EOL)
 
 #define PRINT_HEADER1(args, header1) \
        do { \
@@ -129,44 +147,59 @@
 #define FIELD_MAXIMUM(field)                           field "_max"
 #define FIELD_PERCENT(field)                           field "_p"
 
-#define VALUE_CURRENT(args, field)                     SCRIPT(args, "VDEF:" FIELD_CURRENT(field) "=" field ",LAST")
-#define VALUE_AVERAGE(args, field)                     SCRIPT(args, "VDEF:" FIELD_AVERAGE(field) "=" field ",AVERAGE")
-#define VALUE_MINIMUM(args, field)                     SCRIPT(args, "VDEF:" FIELD_MINIMUM(field) "=" field ",MINIMUM")
-#define VALUE_MAXIMUM(args, field)                     SCRIPT(args, "VDEF:" FIELD_MAXIMUM(field) "=" field ",MAXIMUM")
+#define VALUE_CURRENT(args, field, object)     SCRIPT(args, "VDEF:" FIELD "=" FIELD ",LAST", FIELD_AND_OBJECT(FIELD_CURRENT(field), object), FIELD_AND_OBJECT(field, object))
+#define VALUE_AVERAGE(args, field, object)     SCRIPT(args, "VDEF:" FIELD "=" FIELD ",AVERAGE", FIELD_AND_OBJECT(FIELD_AVERAGE(field), object), FIELD_AND_OBJECT(field, object))
+#define VALUE_MINIMUM(args, field, object)     SCRIPT(args, "VDEF:" FIELD "=" FIELD ",MINIMUM", FIELD_AND_OBJECT(FIELD_MINIMUM(field), object), FIELD_AND_OBJECT(field, object))
+#define VALUE_MAXIMUM(args, field, object)     SCRIPT(args, "VDEF:" FIELD "=" FIELD ",MAXIMUM", FIELD_AND_OBJECT(FIELD_MAXIMUM(field), object), FIELD_AND_OBJECT(field, object))
 
 // Computes all values
-#define VALUE_ALL(args, field) \
+#define VALUE_ALL(args, field, object) \
        do { \
-               VALUE_CURRENT(args, field); \
-               VALUE_AVERAGE(args, field); \
-               VALUE_MINIMUM(args, field); \
-               VALUE_MAXIMUM(args, field); \
+               VALUE_CURRENT(args, field, object); \
+               VALUE_AVERAGE(args, field, object); \
+               VALUE_MINIMUM(args, field, object); \
+               VALUE_MAXIMUM(args, field, object); \
        } while (0)
 
-#define COMPUTE_CDEF(args, cdef)                       SCRIPT(args, "CDEF:" cdef)
+#define COMPUTE_CDEF(args, cdef, ...)                  SCRIPT(args, "CDEF:" cdef, ##__VA_ARGS__)
 
-#define COMPUTE_SUM(args, sum, summand1, summand2) \
+#define COMPUTE_SUM(args, sum, object1, summand1, object2, summand2, object3) \
        do { \
-               COMPUTE_CDEF(args, sum "=" summand1 "," summand2 ",+"); \
-               VALUE_ALL(args, sum); \
+               COMPUTE_CDEF(args, FIELD "=" FIELD "," FIELD ",+", \
+                       FIELD_AND_OBJECT(sum, object1), \
+                       FIELD_AND_OBJECT(summand1, object2), \
+                       FIELD_AND_OBJECT(summand2, object3) \
+               ); \
+               VALUE_ALL(args, sum, object1); \
        } while (0)
 
-#define COMPUTE_DIFFERENCE(args, difference, term, subtrahend) \
+#define COMPUTE_DIFFERENCE(args, difference, object1, term, object2, subtrahend, object3) \
        do { \
-               COMPUTE_CDEF(args, difference "=" term "," subtrahend ",-"); \
-               VALUE_ALL(args, difference); \
+               COMPUTE_CDEF(args, FIELD "=" FIELD "," FIELD ",-", \
+                       FIELD_AND_OBJECT(difference, object1), \
+                       FIELD_AND_OBJECT(term, object2), \
+                       FIELD_AND_OBJECT(subtrahend, object3) \
+               ); \
+               VALUE_ALL(args, difference, object); \
        } while (0)
 
-#define COMPUTE_DIVIDE(args, fraction, dividend, divisor) \
+#define COMPUTE_DIVIDE(args, fraction, object1, dividend, object2, divisor) \
        do { \
-               COMPUTE_CDEF(args, fraction "=" dividend "," TOSTRING(divisor) ",/"); \
-               VALUE_ALL(args, fraction); \
+               COMPUTE_CDEF(args, FIELD "=" FIELD "," TOSTRING(divisor) ",/", \
+                       FIELD_AND_OBJECT(fraction, object1), \
+                       FIELD_AND_OBJECT(dividend, object2) \
+               ); \
+               VALUE_ALL(args, fraction, object1); \
        } while (0)
 
-#define COMPUTE_PERCENTAGE(args, field, total) \
+#define COMPUTE_PERCENTAGE(args, field, object1, total, object2) \
        do { \
-               COMPUTE_CDEF(args, FIELD_PERCENT(field) "=100," field ",*," total ",/"); \
-               VALUE_ALL(args, FIELD_PERCENT(field)); \
+               COMPUTE_CDEF(args, FIELD "=100," FIELD ",*," FIELD ",/", \
+                       FIELD_AND_OBJECT(FIELD_PERCENT(field), object1), \
+                       FIELD_AND_OBJECT(field, object1), \
+                       FIELD_AND_OBJECT(total, object2) \
+               ); \
+               VALUE_ALL(args, FIELD_PERCENT(field), object1); \
        } while (0)
 
 

diff --git a/src/daemon/graphs/loadavg.c b/src/daemon/graphs/loadavg.c
index 82302ab8850ab46939d7c7907985bab1f0899257..04e8313158f38532faf1f9c2f3bda847225ec6f9 100644 (file)
--- a/src/daemon/graphs/loadavg.c
+++ b/src/daemon/graphs/loadavg.c
@@ -39,7 +39,7 @@ static int loadavg_render(td_ctx* ctx,
        int r;
 
        // This requires the loadavg source
-       r = td_graph_require_source(graph, args, "loadavg", object);
+       r = td_graph_require_source(graph, args, "loadavg", NULL);
        if (r < 0)
                return r;
 
@@ -52,27 +52,30 @@ static int loadavg_render(td_ctx* ctx,
        COMPUTE_CDEF(args, "delta1+=delta1,0,delta1,LIMIT");
 
        // Draw the area backgrouns
-       DRAW_AREA_BACKGROUND(args, "load15", COLOR_LOAD15);
-       DRAW_AREA_BACKGROUND(args, "delta5+", COLOR_LOAD5, STACK);
-       DRAW_AREA_BACKGROUND(args, "delta1+", COLOR_LOAD1, STACK);
-
-       DRAW_AREA_OUTLINE_WITH_LABEL(args, "load15", COLOR_LOAD15, _("15 Minutes"));
-       PRINT_FLOAT(args, "load15_cur");
-       PRINT_FLOAT(args, "load15_avg");
-       PRINT_FLOAT(args, "load15_min");
-       PRINT_FLOAT(args, "load15_max", EOL);
-
-       DRAW_AREA_OUTLINE_WITH_LABEL(args, "load5", COLOR_LOAD5, _("5 Minutes"));
-       PRINT_FLOAT(args, "load5_cur");
-       PRINT_FLOAT(args, "load5_avg");
-       PRINT_FLOAT(args, "load5_min");
-       PRINT_FLOAT(args, "load5_max", EOL);
-
-       DRAW_AREA_OUTLINE_WITH_LABEL(args, "load1", COLOR_LOAD1, _("1 Minute"));
-       PRINT_FLOAT(args, "load1_cur");
-       PRINT_FLOAT(args, "load1_avg");
-       PRINT_FLOAT(args, "load1_min");
-       PRINT_FLOAT(args, "load1_max", EOL);
+       DRAW_AREA_BACKGROUND(args, "load15", NULL, COLOR_LOAD15);
+       DRAW_AREA_BACKGROUND(args, "delta5+", NULL, COLOR_LOAD5, STACK);
+       DRAW_AREA_BACKGROUND(args, "delta1+", NULL, COLOR_LOAD1, STACK);
+
+       DRAW_AREA_OUTLINE_WITH_LABEL(args, "load15", NULL, COLOR_LOAD15, _("15 Minutes"));
+       PRINT_FLOAT(args, FIELD_CURRENT("load15"), NULL);
+       PRINT_FLOAT(args, FIELD_AVERAGE("load15"), NULL);
+       PRINT_FLOAT(args, FIELD_MINIMUM("load15"), NULL);
+       PRINT_FLOAT(args, FIELD_MAXIMUM("load15"), NULL);
+       PRINT_EOL(args);
+
+       DRAW_AREA_OUTLINE_WITH_LABEL(args, "load5", NULL, COLOR_LOAD5, _("5 Minutes"));
+       PRINT_FLOAT(args, FIELD_CURRENT("load5"), NULL);
+       PRINT_FLOAT(args, FIELD_AVERAGE("load5"), NULL);
+       PRINT_FLOAT(args, FIELD_MINIMUM("load5"), NULL);
+       PRINT_FLOAT(args, FIELD_MAXIMUM("load5"), NULL);
+       PRINT_EOL(args);
+
+       DRAW_AREA_OUTLINE_WITH_LABEL(args, "load1", NULL, COLOR_LOAD1, _("1 Minute"));
+       PRINT_FLOAT(args, FIELD_CURRENT("load1"), NULL);
+       PRINT_FLOAT(args, FIELD_AVERAGE("load1"), NULL);
+       PRINT_FLOAT(args, FIELD_MINIMUM("load1"), NULL);
+       PRINT_FLOAT(args, FIELD_MAXIMUM("load1"), NULL);
+       PRINT_EOL(args);
 
        // Header
        PRINT_HEADER4(args, _("Current"), _("Average"), _("Minimum"), _("Maximum"));

diff --git a/src/daemon/graphs/memory.c b/src/daemon/graphs/memory.c
index b29b225bd9c0eb6dddfef5ba52057287ddc58753..a325570f6759d077c38a47ad2f9fcaaa28d196d4 100644 (file)
--- a/src/daemon/graphs/memory.c
+++ b/src/daemon/graphs/memory.c
@@ -47,7 +47,7 @@ static int memory_render(td_ctx* ctx,
        int r;
 
        // This requires the loadavg source
-       r = td_graph_require_source(graph, args, "memory", object);
+       r = td_graph_require_source(graph, args, "memory", NULL);
        if (r < 0)
                return r;
 
@@ -55,66 +55,73 @@ static int memory_render(td_ctx* ctx,
        PRINT_HEADER4(args, _("Current"), _("Average"), _("Minimum"), _("Maximum"));
 
        // Compute the used memory
-       COMPUTE_DIFFERENCE(args, "mem_used", "mem_total", "mem_available");
-       COMPUTE_PERCENTAGE(args, "mem_used", "mem_total");
+       COMPUTE_DIFFERENCE(args, "mem_used", NULL, "mem_total", NULL, "mem_available", NULL);
+       COMPUTE_PERCENTAGE(args, "mem_used", NULL, "mem_total", NULL);
 
        // Compute the used swap
-       COMPUTE_DIFFERENCE(args, "swap_used", "swap_total", "swap_free");
-       COMPUTE_PERCENTAGE(args, "swap_used", "swap_total");
+       COMPUTE_DIFFERENCE(args, "swap_used", NULL, "swap_total", NULL, "swap_free", NULL);
+       COMPUTE_PERCENTAGE(args, "swap_used", NULL, "swap_total", NULL);
 
        // Draw the stacked background first
-       DRAW_AREA_BACKGROUND(args, "mem_used", COLOR_MEM_USED);
-       DRAW_AREA_BACKGROUND(args, "buffers", COLOR_BUFFERS, STACK);
-       DRAW_AREA_BACKGROUND(args, "cached", COLOR_CACHED, STACK);
+       DRAW_AREA_BACKGROUND(args, "mem_used", NULL, COLOR_MEM_USED);
+       DRAW_AREA_BACKGROUND(args, "buffers", NULL, COLOR_BUFFERS, STACK);
+       DRAW_AREA_BACKGROUND(args, "cached", NULL, COLOR_CACHED, STACK);
 
        // Draw the area outlines afterwards
-       DRAW_AREA_OUTLINE_WITH_LABEL(args, "mem_used", COLOR_MEM_USED, _("Used Memory"));
-       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("mem_used"));
-       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("mem_used"));
-       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("mem_used"));
-       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("mem_used"), EOL);
+       DRAW_AREA_OUTLINE_WITH_LABEL(args, "mem_used", NULL, COLOR_MEM_USED, _("Used Memory"));
+       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("mem_used"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("mem_used"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("mem_used"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("mem_used"), NULL);
+       PRINT_EOL(args);
 
        PRINT_EMPTY_LABEL(args);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("mem_used")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("mem_used")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("mem_used")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("mem_used")), EOL);
-
-       DRAW_AREA_OUTLINE_WITH_LABEL(args, "buffers", COLOR_BUFFERS, _("Buffers"), STACK);
-       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("buffers"));
-       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("buffers"));
-       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("buffers"));
-       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("buffers"), EOL);
-
-       DRAW_AREA_OUTLINE_WITH_LABEL(args, "cached", COLOR_CACHED, _("Cached"), STACK);
-       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("cached"));
-       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("cached"));
-       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("cached"));
-       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("cached"), EOL);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("mem_used")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("mem_used")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("mem_used")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("mem_used")), NULL);
+       PRINT_EOL(args);
+
+       DRAW_AREA_OUTLINE_WITH_LABEL(args, "buffers", NULL, COLOR_BUFFERS, _("Buffers"), STACK);
+       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("buffers"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("buffers"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("buffers"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("buffers"), NULL);
+       PRINT_EOL(args);
+
+       DRAW_AREA_OUTLINE_WITH_LABEL(args, "cached", NULL, COLOR_CACHED, _("Cached"), STACK);
+       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("cached"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("cached"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("cached"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("cached"), NULL);
+       PRINT_EOL(args);
 
        // Draw the total memory as a line
-       DRAW_LINE1(args, "mem_total", COLOR_MEM_TOTAL);
+       DRAW_LINE1(args, "mem_total", NULL, COLOR_MEM_TOTAL);
 
        // Make some space for swap
        PRINT_EMPTY_LINE(args);
 
-       DRAW_LINE1_WITH_LABEL(args, "swap_used", COLOR_SWAP_USED, _("Used Swap"), DASHES);
-       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("swap_used"));
-       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("swap_used"));
-       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("swap_used"));
-       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("swap_used"), EOL);
+       DRAW_LINE1_WITH_LABEL(args, "swap_used", NULL, COLOR_SWAP_USED, _("Used Swap"), DASHES);
+       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("swap_used"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_AVERAGE("swap_used"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MINIMUM("swap_used"), NULL);
+       PRINT_LARGE_FLOAT(args, FIELD_MAXIMUM("swap_used"), NULL);
+       PRINT_EOL(args);
 
        PRINT_EMPTY_LABEL(args);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("swap_used")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("swap_used")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("swap_used")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("swap_used")), EOL);
-
-       DRAW_LINE1_WITH_LABEL(args, "swap_total", COLOR_SWAP_TOTAL, _("Total Swap"), DASHES);
-       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("swap_used"));
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("swap_used")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("swap_used")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("swap_used")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("swap_used")), NULL);
+       PRINT_EOL(args);
+
+       DRAW_LINE1_WITH_LABEL(args, "swap_total", NULL, COLOR_SWAP_TOTAL, _("Total Swap"), DASHES);
+       PRINT_LARGE_FLOAT(args, FIELD_CURRENT("swap_used"), NULL);
        PRINT_NOTHING(args);
        PRINT_NOTHING(args);
        PRINT_NOTHING(args);
+       PRINT_EOL(args);
 
        return 0;
 }

diff --git a/src/daemon/graphs/processor.c b/src/daemon/graphs/processor.c
index b7e7c20260b643b2ac424b996a924fcff2fb6034..e24369bc4da1313f7a33e444b5e90e181f9deca8 100644 (file)
--- a/src/daemon/graphs/processor.c
+++ b/src/daemon/graphs/processor.c
@@ -49,7 +49,7 @@ static int processor_render(td_ctx* ctx,
        int r;
 
        // This requires the loadavg source
-       r = td_graph_require_source(graph, args, "processor", object);
+       r = td_graph_require_source(graph, args, "processor", NULL);
        if (r < 0)
                return r;
 
@@ -60,106 +60,116 @@ static int processor_render(td_ctx* ctx,
                return r;
 
        // Add idle to get the total number of cycles
-       COMPUTE_SUM(args, "total", "usage", "idle");
+       COMPUTE_SUM(args, "total", NULL, "usage", NULL, "idle", NULL);
 
        // Compute usage in percent
-       COMPUTE_PERCENTAGE(args, "usage", "total");
-       COMPUTE_PERCENTAGE(args, "user", "total");
-       COMPUTE_PERCENTAGE(args, "nice", "total");
-       COMPUTE_PERCENTAGE(args, "sys", "total");
-       COMPUTE_PERCENTAGE(args, "wait", "total");
-       COMPUTE_PERCENTAGE(args, "irq", "total");
-       COMPUTE_PERCENTAGE(args, "softirq", "total");
-       COMPUTE_PERCENTAGE(args, "steal", "total");
-       COMPUTE_PERCENTAGE(args, "guest", "total");
-       COMPUTE_PERCENTAGE(args, "guest_nice", "total");
+       COMPUTE_PERCENTAGE(args, "usage", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "user", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "nice", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "sys", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "wait", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "irq", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "softirq", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "steal", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "guest", NULL, "total", NULL);
+       COMPUTE_PERCENTAGE(args, "guest_nice", NULL, "total", NULL);
 
        // Header
        PRINT_HEADER4(args, _("Current"), _("Average"), _("Minimum"), _("Maximum"));
 
        // Show the total usage
        PRINT_LABEL(args, _("Total"));
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("usage")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("usage")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("usage")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("usage")), EOL);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("usage")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("usage")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("usage")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("usage")), NULL);
+       PRINT_EOL(args);
 
        PRINT_EMPTY_LINE(args);
 
        // Draw the stacked background first
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("user"), COLOR_USER);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("nice"), COLOR_NICE, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("sys"), COLOR_SYS, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("wait"), COLOR_WAIT, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("irq"), COLOR_IRQ, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("softirq"), COLOR_SOFTIRQ, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("steal"), COLOR_STEAL, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("guest"), COLOR_GUEST, STACK);
-       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("guest_nice"), COLOR_GUEST_NICE, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("user"), NULL, COLOR_USER);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("nice"), NULL, COLOR_NICE, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("sys"), NULL, COLOR_SYS, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("wait"), NULL, COLOR_WAIT, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("irq"), NULL, COLOR_IRQ, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("softirq"), NULL, COLOR_SOFTIRQ, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("steal"), NULL, COLOR_STEAL, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("guest"), NULL, COLOR_GUEST, STACK);
+       DRAW_AREA_BACKGROUND(args, FIELD_PERCENT("guest_nice"), NULL, COLOR_GUEST_NICE, STACK);
 
        // Draw the area outlines afterwards
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("user"), COLOR_USER, _("User"));
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("user")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("user")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("user")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("user")), EOL);
+               FIELD_PERCENT("user"), NULL, COLOR_USER, _("User"));
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("user")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("user")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("user")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("user")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("nice"), COLOR_NICE, _("Nice"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("nice")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("nice")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("nice")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("nice")), EOL);
+               FIELD_PERCENT("nice"), NULL, COLOR_NICE, _("Nice"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("nice")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("nice")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("nice")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("nice")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("sys"), COLOR_SYS, _("Sys"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("sys")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("sys")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("sys")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("sys")), EOL);
+               FIELD_PERCENT("sys"), NULL, COLOR_SYS, _("Sys"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("sys")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("sys")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("sys")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("sys")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("wait"), COLOR_WAIT, _("Wait"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("wait")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("wait")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("wait")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("wait")), EOL);
+               FIELD_PERCENT("wait"), NULL, COLOR_WAIT, _("Wait"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("wait")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("wait")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("wait")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("wait")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("irq"), COLOR_IRQ, _("Interrupt"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("irq")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("irq")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("irq")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("irq")), EOL);
+               FIELD_PERCENT("irq"), NULL, COLOR_IRQ, _("Interrupt"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("irq")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("irq")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("irq")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("irq")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("softirq"), COLOR_SOFTIRQ, _("Soft Interrupt"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("softirq")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("softirq")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("softirq")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("softirq")), EOL);
+               FIELD_PERCENT("softirq"), NULL, COLOR_SOFTIRQ, _("Soft Interrupt"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("softirq")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("softirq")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("softirq")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("softirq")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("steal"), COLOR_STEAL, _("Steal"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("steal")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("steal")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("steal")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("steal")), EOL);
+               FIELD_PERCENT("steal"), NULL, COLOR_STEAL, _("Steal"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("steal")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("steal")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("steal")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("steal")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("guest"), COLOR_GUEST, _("Guest"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("guest")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("guest")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("guest")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("guest")), EOL);
+               FIELD_PERCENT("guest"), NULL, COLOR_GUEST, _("Guest"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("guest")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("guest")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("guest")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("guest")), NULL);
+       PRINT_EOL(args);
 
        DRAW_AREA_OUTLINE_WITH_LABEL(args,
-               FIELD_PERCENT("guest_nice"), COLOR_GUEST_NICE, _("Guest Nice"), STACK);
-       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("guest_nice")));
-       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("guest_nice")));
-       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("guest_nice")));
-       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("guest_nice")), EOL);
+               FIELD_PERCENT("guest_nice"), NULL, COLOR_GUEST_NICE, _("Guest Nice"), STACK);
+       PRINT_PERCENTAGE(args, FIELD_CURRENT(FIELD_PERCENT("guest_nice")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_AVERAGE(FIELD_PERCENT("guest_nice")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MINIMUM(FIELD_PERCENT("guest_nice")), NULL);
+       PRINT_PERCENTAGE(args, FIELD_MAXIMUM(FIELD_PERCENT("guest_nice")), NULL);
+       PRINT_EOL(args);
 
        return 0;
 }

diff --git a/src/daemon/graphs/uptime.c b/src/daemon/graphs/uptime.c
index d6460a6f08239275b70a4174a56f73a04f761326..9f0e37c55232d21b81b2e6a4369b33589ec86519 100644 (file)
--- a/src/daemon/graphs/uptime.c
+++ b/src/daemon/graphs/uptime.c
@@ -39,18 +39,18 @@ static int uptime_render(td_ctx* ctx,
        int r;
 
        // This requires the uptime source
-       r = td_graph_require_source(graph, args, "uptime", object);
+       r = td_graph_require_source(graph, args, "uptime", NULL);
        if (r < 0)
                return r;
 
        // Convert the uptime into days
-       COMPUTE_DIVIDE(args, "uptime_days", "uptime", 86400);
+       COMPUTE_DIVIDE(args, "uptime_days", NULL, "uptime", NULL, 86400);
 
        // Header
        PRINT_HEADER1(args, _("Current"));
 
        // Draw the uptime
-       DRAW_AREA_WITH_LABEL(args, "uptime_days", DEFAULT, _("Uptime"));
+       DRAW_AREA_WITH_LABEL(args, "uptime_days", NULL, DEFAULT, _("Uptime"));
        PRINT_INTEGER(args, "uptime_days_cur", EOL);
 
        return 0;