Merging upstream version 2.0.3+dfsg (Closes: #923993, #1042533, #1045145).

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

19 files changed, 3269 insertions, 0 deletions

diff --git a/src/web/api/v1/api_v1_aclk.c b/src/web/api/v1/api_v1_aclk.c
new file mode 100644
index 000000000..b9878db2f
--- /dev/null
+++ b/src/web/api/v1/api_v1_aclk.c
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_aclk(RRDHOST *host, struct web_client *w, char *url) {
+    UNUSED(url);
+    UNUSED(host);
+    if (!netdata_ready) return HTTP_RESP_SERVICE_UNAVAILABLE;
+
+    BUFFER *wb = w->response.data;
+    buffer_flush(wb);
+    char *str = aclk_state_json();
+    buffer_strcat(wb, str);
+    freez(str);
+
+    wb->content_type = CT_APPLICATION_JSON;
+    buffer_no_cacheable(wb);
+    return HTTP_RESP_OK;
+}
+
diff --git a/src/web/api/v1/api_v1_alarms.c b/src/web/api/v1/api_v1_alarms.c
new file mode 100644
index 000000000..4f3af74b5
--- /dev/null
+++ b/src/web/api/v1/api_v1_alarms.c
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+static int web_client_api_request_v1_alarms_select(char *url) {
+    int all = 0;
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if (!value || !*value) continue;
+
+        if(!strcmp(value, "all") || !strcmp(value, "all=true")) all = 1;
+        else if(!strcmp(value, "active") || !strcmp(value, "active=true")) all = 0;
+    }
+
+    return all;
+}
+
+int api_v1_alarms(RRDHOST *host, struct web_client *w, char *url) {
+    int all = web_client_api_request_v1_alarms_select(url);
+
+    buffer_flush(w->response.data);
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    health_alarms2json(host, w->response.data, all);
+    buffer_no_cacheable(w->response.data);
+    return HTTP_RESP_OK;
+}
+
+int api_v1_alarms_values(RRDHOST *host, struct web_client *w, char *url) {
+    int all = web_client_api_request_v1_alarms_select(url);
+
+    buffer_flush(w->response.data);
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    health_alarms_values2json(host, w->response.data, all);
+    buffer_no_cacheable(w->response.data);
+    return HTTP_RESP_OK;
+}
+
+int api_v1_alarm_count(RRDHOST *host, struct web_client *w, char *url) {
+    RRDCALC_STATUS status = RRDCALC_STATUS_RAISED;
+    BUFFER *contexts = NULL;
+
+    buffer_flush(w->response.data);
+    buffer_sprintf(w->response.data, "[");
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        netdata_log_debug(D_WEB_CLIENT, "%llu: API v1 alarm_count query param '%s' with value '%s'", w->id, name, value);
+
+        char* p = value;
+        if(!strcmp(name, "status")) {
+            while ((*p = toupper(*p))) p++;
+            if (!strcmp("CRITICAL", value)) status = RRDCALC_STATUS_CRITICAL;
+            else if (!strcmp("WARNING", value)) status = RRDCALC_STATUS_WARNING;
+            else if (!strcmp("UNINITIALIZED", value)) status = RRDCALC_STATUS_UNINITIALIZED;
+            else if (!strcmp("UNDEFINED", value)) status = RRDCALC_STATUS_UNDEFINED;
+            else if (!strcmp("REMOVED", value)) status = RRDCALC_STATUS_REMOVED;
+            else if (!strcmp("CLEAR", value)) status = RRDCALC_STATUS_CLEAR;
+        }
+        else if(!strcmp(name, "context") || !strcmp(name, "ctx")) {
+            if(!contexts) contexts = buffer_create(255, &netdata_buffers_statistics.buffers_api);
+            buffer_strcat(contexts, "|");
+            buffer_strcat(contexts, value);
+        }
+    }
+
+    health_aggregate_alarms(host, w->response.data, contexts, status);
+
+    buffer_sprintf(w->response.data, "]\n");
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    buffer_no_cacheable(w->response.data);
+
+    buffer_free(contexts);
+    return 200;
+}
+
+int api_v1_alarm_log(RRDHOST *host, struct web_client *w, char *url) {
+    time_t after = 0;
+    char *chart = NULL;
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if (!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        if (!strcmp(name, "after")) after = (time_t) strtoul(value, NULL, 0);
+        else if (!strcmp(name, "chart")) chart = value;
+    }
+
+    buffer_flush(w->response.data);
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    sql_health_alarm_log2json(host, w->response.data, after, chart);
+    return HTTP_RESP_OK;
+}
+
+int api_v1_variable(RRDHOST *host, struct web_client *w, char *url) {
+    int ret = HTTP_RESP_BAD_REQUEST;
+    char *chart = NULL;
+    char *variable = NULL;
+
+    buffer_flush(w->response.data);
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "chart")) chart = value;
+        else if(!strcmp(name, "variable")) variable = value;
+    }
+
+    if(!chart || !*chart || !variable || !*variable) {
+        buffer_sprintf(w->response.data, "A chart= and a variable= are required.");
+        goto cleanup;
+    }
+
+    RRDSET *st = rrdset_find(host, chart);
+    if(!st) st = rrdset_find_byname(host, chart);
+    if(!st) {
+        buffer_strcat(w->response.data, "Chart is not found: ");
+        buffer_strcat_htmlescape(w->response.data, chart);
+        ret = HTTP_RESP_NOT_FOUND;
+        goto cleanup;
+    }
+
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    st->last_accessed_time_s = now_realtime_sec();
+    alert_variable_lookup_trace(host, st, variable, w->response.data);
+
+    return HTTP_RESP_OK;
+
+cleanup:
+    return ret;
+}
+
+int api_v1_alarm_variables(RRDHOST *host, struct web_client *w, char *url) {
+    return api_v1_single_chart_helper(host, w, url, health_api_v1_chart_variables2json);
+}
+
diff --git a/src/web/api/v1/api_v1_allmetrics.c b/src/web/api/v1/api_v1_allmetrics.c
new file mode 100644
index 000000000..593475efd
--- /dev/null
+++ b/src/web/api/v1/api_v1_allmetrics.c
@@ -0,0 +1,308 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+#define ALLMETRICS_FORMAT_SHELL                 "shell"
+#define ALLMETRICS_FORMAT_PROMETHEUS            "prometheus"
+#define ALLMETRICS_FORMAT_PROMETHEUS_ALL_HOSTS  "prometheus_all_hosts"
+#define ALLMETRICS_FORMAT_JSON                  "json"
+
+#define ALLMETRICS_SHELL                        1
+#define ALLMETRICS_PROMETHEUS                   2
+#define ALLMETRICS_JSON                         3
+#define ALLMETRICS_PROMETHEUS_ALL_HOSTS         4
+
+struct prometheus_output_options {
+    char *name;
+    PROMETHEUS_OUTPUT_OPTIONS flag;
+} prometheus_output_flags_root[] = {
+    { "names",      PROMETHEUS_OUTPUT_NAMES      },
+    { "timestamps", PROMETHEUS_OUTPUT_TIMESTAMPS },
+    { "variables",  PROMETHEUS_OUTPUT_VARIABLES  },
+    { "oldunits",   PROMETHEUS_OUTPUT_OLDUNITS   },
+    { "hideunits",  PROMETHEUS_OUTPUT_HIDEUNITS  },
+    // terminator
+    { NULL, PROMETHEUS_OUTPUT_NONE },
+};
+
+// ----------------------------------------------------------------------------
+// BASH
+// /api/v1/allmetrics?format=bash
+
+static inline size_t shell_name_copy(char *d, const char *s, size_t usable) {
+    size_t n;
+
+    for(n = 0; *s && n < usable ; d++, s++, n++) {
+        register char c = *s;
+
+        if(unlikely(!isalnum(c))) *d = '_';
+        else *d = (char)toupper(c);
+    }
+    *d = '\0';
+
+    return n;
+}
+
+#define SHELL_ELEMENT_MAX 100
+
+void rrd_stats_api_v1_charts_allmetrics_shell(RRDHOST *host, const char *filter_string, BUFFER *wb) {
+    analytics_log_shell();
+    SIMPLE_PATTERN *filter = simple_pattern_create(filter_string, NULL, SIMPLE_PATTERN_EXACT, true);
+
+    // for each chart
+    RRDSET *st;
+    rrdset_foreach_read(st, host) {
+        if (filter && !simple_pattern_matches_string(filter, st->name))
+            continue;
+        if (rrdset_is_available_for_viewers(st)) {
+            NETDATA_DOUBLE total = 0.0;
+
+            char chart[SHELL_ELEMENT_MAX + 1];
+            shell_name_copy(chart, st->name ? rrdset_name(st) : rrdset_id(st), SHELL_ELEMENT_MAX);
+
+            buffer_sprintf(wb, "\n# chart: %s (name: %s)\n", rrdset_id(st), rrdset_name(st));
+
+            // for each dimension
+            RRDDIM *rd;
+            rrddim_foreach_read(rd, st) {
+                if(rd->collector.counter && !rrddim_flag_check(rd, RRDDIM_FLAG_OBSOLETE)) {
+                    char dimension[SHELL_ELEMENT_MAX + 1];
+                    shell_name_copy(dimension, rd->name?rrddim_name(rd):rrddim_id(rd), SHELL_ELEMENT_MAX);
+
+                    NETDATA_DOUBLE n = rd->collector.last_stored_value;
+
+                    if(isnan(n) || isinf(n))
+                        buffer_sprintf(wb, "NETDATA_%s_%s=\"\"      # %s\n", chart, dimension, rrdset_units(st));
+                    else {
+                        if(rd->multiplier < 0 || rd->divisor < 0) n = -n;
+                        n = roundndd(n);
+                        if(!rrddim_option_check(rd, RRDDIM_OPTION_HIDDEN)) total += n;
+                        buffer_sprintf(wb, "NETDATA_%s_%s=\"" NETDATA_DOUBLE_FORMAT_ZERO "\"      # %s\n", chart, dimension, n, rrdset_units(st));
+                    }
+                }
+            }
+            rrddim_foreach_done(rd);
+
+            total = roundndd(total);
+            buffer_sprintf(wb, "NETDATA_%s_VISIBLETOTAL=\"" NETDATA_DOUBLE_FORMAT_ZERO "\"      # %s\n", chart, total, rrdset_units(st));
+        }
+    }
+    rrdset_foreach_done(st);
+
+    buffer_strcat(wb, "\n# NETDATA ALARMS RUNNING\n");
+
+    RRDCALC *rc;
+    foreach_rrdcalc_in_rrdhost_read(host, rc) {
+        if(!rc->rrdset) continue;
+
+        char chart[SHELL_ELEMENT_MAX + 1];
+        shell_name_copy(chart, rc->rrdset->name?rrdset_name(rc->rrdset):rrdset_id(rc->rrdset), SHELL_ELEMENT_MAX);
+
+        char alarm[SHELL_ELEMENT_MAX + 1];
+        shell_name_copy(alarm, rrdcalc_name(rc), SHELL_ELEMENT_MAX);
+
+        NETDATA_DOUBLE n = rc->value;
+
+        if(isnan(n) || isinf(n))
+            buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_VALUE=\"\"      # %s\n", chart, alarm, rrdcalc_units(rc));
+        else {
+            n = roundndd(n);
+            buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_VALUE=\"" NETDATA_DOUBLE_FORMAT_ZERO "\"      # %s\n", chart, alarm, n, rrdcalc_units(rc));
+        }
+
+        buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_STATUS=\"%s\"\n", chart, alarm, rrdcalc_status2string(rc->status));
+    }
+    foreach_rrdcalc_in_rrdhost_done(rc);
+
+    simple_pattern_free(filter);
+}
+
+// ----------------------------------------------------------------------------
+
+void rrd_stats_api_v1_charts_allmetrics_json(RRDHOST *host, const char *filter_string, BUFFER *wb) {
+    analytics_log_json();
+    SIMPLE_PATTERN *filter = simple_pattern_create(filter_string, NULL, SIMPLE_PATTERN_EXACT, true);
+
+    buffer_strcat(wb, "{");
+
+    size_t chart_counter = 0;
+    size_t dimension_counter = 0;
+
+    // for each chart
+    RRDSET *st;
+    rrdset_foreach_read(st, host) {
+        if (filter && !(simple_pattern_matches_string(filter, st->id) || simple_pattern_matches_string(filter, st->name)))
+            continue;
+
+        if(rrdset_is_available_for_viewers(st)) {
+            buffer_sprintf(
+                wb,
+                "%s\n"
+                "\t\"%s\": {\n"
+                "\t\t\"name\":\"%s\",\n"
+                "\t\t\"family\":\"%s\",\n"
+                "\t\t\"context\":\"%s\",\n"
+                "\t\t\"units\":\"%s\",\n"
+                "\t\t\"last_updated\": %"PRId64",\n"
+                "\t\t\"dimensions\": {",
+                chart_counter ? "," : "",
+                rrdset_id(st),
+                rrdset_name(st),
+                rrdset_family(st),
+                rrdset_context(st),
+                rrdset_units(st),
+                (int64_t) rrdset_last_entry_s(st));
+
+            chart_counter++;
+            dimension_counter = 0;
+
+            // for each dimension
+            RRDDIM *rd;
+            rrddim_foreach_read(rd, st) {
+                if(rd->collector.counter && !rrddim_flag_check(rd, RRDDIM_FLAG_OBSOLETE)) {
+                    buffer_sprintf(
+                        wb,
+                        "%s\n"
+                        "\t\t\t\"%s\": {\n"
+                        "\t\t\t\t\"name\": \"%s\",\n"
+                        "\t\t\t\t\"value\": ",
+                        dimension_counter ? "," : "",
+                        rrddim_id(rd),
+                        rrddim_name(rd));
+
+                    if(isnan(rd->collector.last_stored_value))
+                        buffer_strcat(wb, "null");
+                    else
+                        buffer_sprintf(wb, NETDATA_DOUBLE_FORMAT, rd->collector.last_stored_value);
+
+                    buffer_strcat(wb, "\n\t\t\t}");
+
+                    dimension_counter++;
+                }
+            }
+            rrddim_foreach_done(rd);
+
+            buffer_strcat(wb, "\n\t\t}\n\t}");
+        }
+    }
+    rrdset_foreach_done(st);
+
+    buffer_strcat(wb, "\n}");
+    simple_pattern_free(filter);
+}
+
+int api_v1_allmetrics(RRDHOST *host, struct web_client *w, char *url) {
+    int format = ALLMETRICS_SHELL;
+    const char *filter = NULL;
+    const char *prometheus_server = w->client_ip;
+
+    uint32_t prometheus_exporting_options;
+    if (prometheus_exporter_instance)
+        prometheus_exporting_options = prometheus_exporter_instance->config.options;
+    else
+        prometheus_exporting_options = global_exporting_options;
+
+    PROMETHEUS_OUTPUT_OPTIONS prometheus_output_options =
+        PROMETHEUS_OUTPUT_TIMESTAMPS |
+        ((prometheus_exporting_options & EXPORTING_OPTION_SEND_NAMES) ? PROMETHEUS_OUTPUT_NAMES : 0);
+
+    const char *prometheus_prefix;
+    if (prometheus_exporter_instance)
+        prometheus_prefix = prometheus_exporter_instance->config.prefix;
+    else
+        prometheus_prefix = global_exporting_prefix;
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if (!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        if(!strcmp(name, "format")) {
+            if(!strcmp(value, ALLMETRICS_FORMAT_SHELL))
+                format = ALLMETRICS_SHELL;
+            else if(!strcmp(value, ALLMETRICS_FORMAT_PROMETHEUS))
+                format = ALLMETRICS_PROMETHEUS;
+            else if(!strcmp(value, ALLMETRICS_FORMAT_PROMETHEUS_ALL_HOSTS))
+                format = ALLMETRICS_PROMETHEUS_ALL_HOSTS;
+            else if(!strcmp(value, ALLMETRICS_FORMAT_JSON))
+                format = ALLMETRICS_JSON;
+            else
+                format = 0;
+        }
+        else if(!strcmp(name, "filter")) {
+            filter = value;
+        }
+        else if(!strcmp(name, "server")) {
+            prometheus_server = value;
+        }
+        else if(!strcmp(name, "prefix")) {
+            prometheus_prefix = value;
+        }
+        else if(!strcmp(name, "data") || !strcmp(name, "source") || !strcmp(name, "data source") || !strcmp(name, "data-source") || !strcmp(name, "data_source") || !strcmp(name, "datasource")) {
+            prometheus_exporting_options = exporting_parse_data_source(value, prometheus_exporting_options);
+        }
+        else {
+            int i;
+            for(i = 0; prometheus_output_flags_root[i].name ; i++) {
+                if(!strcmp(name, prometheus_output_flags_root[i].name)) {
+                    if(!strcmp(value, "yes") || !strcmp(value, "1") || !strcmp(value, "true"))
+                        prometheus_output_options |= prometheus_output_flags_root[i].flag;
+                    else {
+                        prometheus_output_options &= ~prometheus_output_flags_root[i].flag;
+                    }
+
+                    break;
+                }
+            }
+        }
+    }
+
+    buffer_flush(w->response.data);
+    buffer_no_cacheable(w->response.data);
+
+    switch(format) {
+        case ALLMETRICS_JSON:
+            w->response.data->content_type = CT_APPLICATION_JSON;
+            rrd_stats_api_v1_charts_allmetrics_json(host, filter, w->response.data);
+            return HTTP_RESP_OK;
+
+        case ALLMETRICS_SHELL:
+            w->response.data->content_type = CT_TEXT_PLAIN;
+            rrd_stats_api_v1_charts_allmetrics_shell(host, filter, w->response.data);
+            return HTTP_RESP_OK;
+
+        case ALLMETRICS_PROMETHEUS:
+            w->response.data->content_type = CT_PROMETHEUS;
+            rrd_stats_api_v1_charts_allmetrics_prometheus_single_host(
+                host
+                , filter
+                , w->response.data
+                , prometheus_server
+                , prometheus_prefix
+                , prometheus_exporting_options
+                , prometheus_output_options
+            );
+            return HTTP_RESP_OK;
+
+        case ALLMETRICS_PROMETHEUS_ALL_HOSTS:
+            w->response.data->content_type = CT_PROMETHEUS;
+            rrd_stats_api_v1_charts_allmetrics_prometheus_all_hosts(
+                host
+                , filter
+                , w->response.data
+                , prometheus_server
+                , prometheus_prefix
+                , prometheus_exporting_options
+                , prometheus_output_options
+            );
+            return HTTP_RESP_OK;
+
+        default:
+            w->response.data->content_type = CT_TEXT_PLAIN;
+            buffer_strcat(w->response.data, "Which format? '" ALLMETRICS_FORMAT_SHELL "', '" ALLMETRICS_FORMAT_PROMETHEUS "', '" ALLMETRICS_FORMAT_PROMETHEUS_ALL_HOSTS "' and '" ALLMETRICS_FORMAT_JSON "' are currently supported.");
+            return HTTP_RESP_BAD_REQUEST;
+    }
+}
diff --git a/src/web/api/v1/api_v1_badge/README.md b/src/web/api/v1/api_v1_badge/README.md
new file mode 100644
index 000000000..d6deb7994
--- /dev/null
+++ b/src/web/api/v1/api_v1_badge/README.md
@@ -0,0 +1,360 @@
+# Netdata badges
+
+**Badges are cool!**
+
+Netdata can generate badges for any chart and any dimension at any time-frame. Badges come in `SVG` and can be added to any web page using an `<IMG>` HTML tag.
+
+**Netdata badges are powerful**!
+
+Given that Netdata collects from **1.000** to **5.000** metrics per server (depending on the number of network interfaces, disks, cpu cores, applications running, users logged in, containers running, etc) and that Netdata already has data reduction/aggregation functions embedded, the badges can be quite powerful.
+
+For each metric/dimension and for arbitrary time-frames badges can show **min**, **max** or **average** value, but also **sum** or **incremental-sum** to have their **volume**.
+
+For example, there is [a chart in Netdata that shows the current requests/s of nginx](http://london.my-netdata.io/#nginx_local_nginx). Using this chart alone we can show the following badges (we could add more time-frames, like **today**, **yesterday**, etc):
+
+<a href="https://registry.my-netdata.io/#nginx_local_nginx"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=nginx_local.connections&dimensions=active&value_color=grey:null%7Cblue&label=nginx%20active%20connections%20now&units=null&precision=0"/></a>  <a href="https://registry.my-netdata.io/#nginx_local_nginx"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=nginx_local.connections&dimensions=active&after=-3600&value_color=orange&label=last%20hour%20average&units=null&options=unaligned&precision=0"/></a> <a href="https://registry.my-netdata.io/#nginx_local_nginx"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=nginx_local.connections&dimensions=active&group=max&after=-3600&value_color=red&label=last%20hour%20max&units=null&options=unaligned&precision=0"/></a>
+
+Similarly, there is [a chart that shows outbound bandwidth per class](http://london.my-netdata.io/#tc_eth0), using QoS data. So it shows `kilobits/s` per class. Using this chart we can show:
+
+<a href="https://registry.my-netdata.io/#tc_eth0"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=tc.world_out&dimensions=web_server&value_color=green&label=web%20server%20sends%20now&units=kbps"/></a> <a href="https://registry.my-netdata.io/#tc_eth0"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=tc.world_out&dimensions=web_server&after=-86400&options=unaligned&group=sum&divide=8388608&value_color=blue&label=web%20server%20sent%20today&units=GB"/></a>
+
+The right one is a **volume** calculation. Netdata calculated the total of the last 86.400 seconds (a day) which gives `kilobits`, then divided it by 8 to make it KB, then by 1024 to make it MB and then by 1024 to make it GB. Calculations like this are quite accurate, since for every value collected, every second, Netdata interpolates it to second boundary using microsecond calculations.
+
+Let's see a few more badge examples (they come from the [Netdata registry](/src/registry/README.md)):
+
+-   **cpu usage of user `root`** (you can pick any user; 100% = 1 core). This will be `green <10%`, `yellow <20%`, `orange <50%`, `blue <100%` (1 core), `red` otherwise (you define thresholds and colors on the URL).
+
+    <a href="https://registry.my-netdata.io/#apps_cpu"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=users.cpu&dimensions=root&value_color=grey:null%7Cgreen%3C10%7Cyellow%3C20%7Corange%3C50%7Cblue%3C100%7Cred&label=root%20user%20cpu%20now&units=%25"></img></a> <a href="https://registry.my-netdata.io/#apps_cpu"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=users.cpu&dimensions=root&after=-3600&value_color=grey:null%7Cgreen%3C10%7Cyellow%3C20%7Corange%3C50%7Cblue%3C100%7Cred&label=root%20user%20average%20cpu%20last%20hour&units=%25"></img></a>
+
+-   **mysql queries per second**
+
+    <a href="https://registry.my-netdata.io/#mysql_local"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=mysql_local.queries&dimensions=questions&label=mysql%20queries%20now&value_color=red&units=%5Cs"></img></a> <a href="https://registry.my-netdata.io/#mysql_local"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=mysql_local.queries&dimensions=questions&after=-3600&options=unaligned&group=sum&label=mysql%20queries%20this%20hour&value_color=green&units=null"></img></a> <a href="https://registry.my-netdata.io/#mysql_local"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=mysql_local.queries&dimensions=questions&after=-86400&options=unaligned&group=sum&label=mysql%20queries%20today&value_color=blue&units=null"></img></a>
+
+    niche ones: **mysql SELECT statements with JOIN, which did full table scans**:
+
+    <a href="https://registry.my-netdata.io/#mysql_local_issues"><img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=mysql_local.join_issues&dimensions=scan&after=-3600&label=full%20table%20scans%20the%20last%20hour&value_color=orange&group=sum&units=null"></img></a>
+
+---
+
+> So, every single line on the charts of a [Netdata dashboard](http://london.my-netdata.io/), can become a badge and this badge can calculate **average**, **min**, **max**, or **volume** for any time-frame! And you can also vary the badge color using conditions on the calculated value.
+
+---
+
+## How to create badges
+
+The basic URL is `http://your.netdata:19999/api/v1/badge.svg?option1&option2&option3&...`.
+
+Here is what you can put for `options` (these are standard Netdata API options):
+
+-   `chart=CHART.NAME`
+
+    The chart to get the values from.
+
+    **This is the only parameter required** and with just this parameter, Netdata will return the sum of the latest values of all chart dimensions.
+
+    Example:
+
+```html
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu"></img>
+  </a>
+```
+
+  Which produces this:
+
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu"></img>
+  </a>
+
+-   `alarm=NAME`
+
+    Render the current value and status of an alert linked to the chart. This option can be ignored if the badge to be generated is not related to an alert.
+
+    The current value of the alert will be rendered. The color of the badge will indicate the status of the alert.
+
+    For alert badges, **both `chart` and `alarm` parameters are required**.
+
+-   `dimensions=DIMENSION1|DIMENSION2|...`
+
+    The dimensions of the chart to use. If you don't set any dimension, all will be used. When multiple dimensions are used, Netdata will sum their values. You can append `options=absolute` if you want this sum to convert all values to positive before adding them.
+
+    Pipes in HTML have to escaped with `%7C`.
+
+    Example:
+
+```html
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&dimensions=system%7Cnice"></img>
+  </a>
+```
+
+  Which produces this:
+
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&dimensions=system%7Cnice"></img>
+  </a>
+
+-   `before=SECONDS` and `after=SECONDS`
+
+    The timeframe. These can be absolute unix timestamps, or relative to now, number of seconds. By default `before=0` and `after=-1` (1 second in the past).
+
+    To get the last minute set `after=-60`. This will give the average of the last complete minute (XX:XX:00 - XX:XX:59).
+
+    To get the max of the last hour set `after=-3600&group=max`. This will give the maximum value of the last complete hour (XX:00:00 - XX:59:59)
+
+    Example:
+
+```html
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60"></img>
+  </a>
+```
+
+  Which produces the average of last complete minute (XX:XX:00 - XX:XX:59):
+
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60"></img>
+  </a>
+
+  While this is the previous minute (one minute before the last one, again aligned XX:XX:00 - XX:XX:59):
+
+```html
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&before=-60&after=-60"></img>
+  </a>
+```
+
+  It produces this:
+
+  <a href="#">
+     <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&before=-60&after=-60"></img>
+  </a>
+
+-   `group=min` or `group=max` or `group=average` (the default) or `group=sum` or `group=incremental-sum`
+
+    If Netdata will have to reduce (aggregate) the data to calculate the value, which aggregation method to use.
+
+    -   `max` will find the max value for the timeframe. This works on both positive and negative dimensions. It will find the most extreme value.
+
+    -   `min` will find the min value for the timeframe. This works on both positive and negative dimensions. It will find the number closest to zero.
+
+    -   `average` will calculate the average value for the timeframe.
+
+    -   `sum` will sum all the values for the timeframe. This is nice for finding the volume of dimensions for a timeframe. So if you have a dimension that reports `X per second`, you can find the volume of the dimension in a timeframe, by adding its values in that timeframe.
+
+    -   `incremental-sum` will sum the difference of each value to its next. Let's assume you have a dimension that does not measure the rate of something, but the absolute value of it. So it has values like this "1, 5, 3, 7, 4". `incremental-sum` will calculate the difference of adjacent values. In this example, they will be `(5 - 1) + (3 - 5) + (7 - 3) + (4 - 7) = 3` (which is equal to the last value minus the first = 4 - 1).
+
+-   `options=opt1|opt2|opt3|...`
+
+    These fine tune various options of the API. Here is what you can use for badges (the API has more option, but only these are useful for badges):
+
+    -   `percentage`, instead of returning a value, calculate the percentage of the sum of the values of the selected dimensions (selected sum / total sum * 100). This also sets the units to `%`.
+
+    -   `absolute` or `abs`, turn all values positive and then sum them.
+
+    -   `display_absolute` or `display-absolute`, to use the signed value during color calculation, but display the absolute value on the badge.
+
+    -   `min2max`, when multiple dimensions are given, do not sum them, but take their `max - min`.
+
+    -   `unaligned`, when data are reduced / aggregated (e.g. the request is about the average of the last minute, or hour), Netdata by default aligns them so that the charts will have a constant shape (so average per minute returns always XX:XX:00 - XX:XX:59). Setting the `unaligned` option, Netdata will aggregate data without any alignment, so if the request is for 60 seconds, it will aggregate the latest 60 seconds of collected data.
+
+These are options dedicated to badges:
+
+-   `label=TEXT`
+
+    The label of the badge.
+
+-   `units=TEXT`
+
+    The units of the badge. If you want to put a `/`, please put a `\`. This is because Netdata allows badges parameters to be given as path in URL, instead of query string. You can also use `null` or `empty` to show it without any units.
+
+    The units `seconds`, `minutes` and `hours` trigger special formatting. The value has to be in this unit, and Netdata will automatically change it to show a more pretty duration.
+
+-   `multiply=NUMBER`
+
+    Multiply the value with this number. The default is `1`.
+
+-   `divide=NUMBER`
+
+    Divide the value with this number. The default is `1`.
+
+-   Color customization parameters
+
+    The following parameters specify colors of each individual part of the badge. Each parameter is documented in detail
+    below.
+
+    | Area of badge      | Background color parameter | Text color parameter |
+    | ---:               | :------------------------: | :------------------: |
+    | Label (left) part  | `label_color`              | `text_color_lbl`     |
+    | Value (right) part | `value_color`              | `text_color_val`     |
+
+    -   `label_color=COLOR`
+
+        The color of the label (the left part). You can use any HTML color in `RGB` or `RRGGBB` hex notation (without
+        the `#` character at the beginning). Additionally, you can use one of the following predefined colors (and you
+        can use them by their name):
+    
+        -   `green`
+        -   `brightgreen`
+        -   `yellow`
+        -   `yellowgreen`
+        -   `orange`
+        -   `red`
+        -   `blue`
+        -   `grey`
+        -   `gray`
+        -   `lightgrey`
+        -   `lightgray`
+    
+        These colors are taken from <https://github.com/badges/shields>, which makes them compatible with standard
+        badges.
+
+    -   `value_color=COLOR:null|COLOR<VALUE|COLOR>VALUE|COLOR>=VALUE|COLOR<=VALUE|...`
+
+        You can add a pipe delimited list of conditions to pick the value color. The first matching (left to right) will
+        be used.
+
+        Example: `value_color=grey:null|green<10|yellow<100|orange<1000|blue<10000|red`
+
+        The above will set `grey` if no value exists (not collected within the `gap when lost iterations above` in
+        `netdata.conf` for the chart), `green` if the value is less than 10, `yellow` if the value is less than 100, and
+        so on. Netdata will use `red` if no other conditions match. Only integers are supported as values.
+
+        The supported operators are `<`, `>`, `<=`, `>=`, `=` (or `:`), and `!=` (or `<>`).
+
+        You can also use the same syntax as the `label_color` parameter to define each of these colors. You can
+        reference a predefined color by name or `RGB`/`RRGGBB` hex notation.
+
+    -   `text_color_lbl=RGB` or `text_color_lbl=RRGGBB` or `text_color_lbl=color_by_name`
+
+        This value specifies the font color for the font of left/label side of the badge. The syntax is the same as the
+        `label_color` parameter. If not given, or given with an empty value, Netdata will use the default color.
+
+    -   `text_color_val=RGB` or `text_color_val=RRGGBB` or `text_color_lbl=color_by_name`
+
+        This value specifies the font color for the font of right/value side of the badge. The syntax is the same as the
+        `label_color` parameter. If not given, or given with an empty value, Netdata will use the default color.
+
+-   `precision=NUMBER`
+
+    The number of decimal digits of the value. By default Netdata will add:
+
+    -   no decimal digits for values > 1000
+    -   1 decimal digit for values > 100
+    -   2 decimal digits for values > 1
+    -   3 decimal digits for values > 0.1
+    -   4 decimal digits for values \<= 0.1
+
+    Using the `precision=NUMBER` you can set your preference per badge.
+
+-   `scale=XXX`
+
+    This option scales the svg image. It accepts values above or equal to 100 (100% is the default scale). For example, lets get a few different sizes:
+
+       <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60&scale=100"></img> original<br/>
+       <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60&scale=125"></img> `scale=125`<br/>
+       <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60&scale=150"></img> `scale=150`<br/>
+       <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60&scale=175"></img> `scale=175`<br/>
+       <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=system.cpu&after=-60&scale=200"></img> `scale=200`
+
+-   `fixed_width_lbl=NUMBER` and `fixed_width_val=NUMBER`
+
+    This parameter overrides auto-sizing of badges and displays them at fixed widths. `fixed_width_lbl` determines the size of the label's left side (label/name). `fixed_width_val` determines the size of the label's right side (value). You must set both parameters together, or they will be ignored.
+    
+    You should set the label/value widths wide enough to provide space for all the possible values/contents of the badge you're requesting. In case the text cannot fit the space given it will be clipped.
+    
+    The `scale` parameter still applies on the values you give to `fixed_width_lbl` and `fixed_width_val`.
+
+-   `refresh=auto` or `refresh=SECONDS`
+
+    This option enables auto-refreshing of images. Netdata will send the HTTP header `Refresh: SECONDS` to the web browser, thus requesting automatic refresh of the images at regular intervals.
+
+    `auto` will calculate the proper `SECONDS` to avoid unnecessary refreshes. If `SECONDS` is zero, this feature is disabled (it is also disabled by default).
+
+    Auto-refreshing like this, works only if you access the badge directly. So, you may have to put it an `embed` or `iframe` for it to be auto-refreshed. Use something like this:
+
+```html
+<embed src="BADGE_URL" type="image/svg+xml" height="20" />
+```
+
+  Another way is to use javascript to auto-refresh them. You can auto-refresh all the Netdata badges on a page using javascript. You have to add a class to all the Netdata badges, like this `<img class="netdata-badge" src="..."/>`. Then add this javascript code to your page (it requires jquery):
+
+```html
+<script>
+    var NETDATA_BADGES_AUTOREFRESH_SECONDS = 5;
+    function refreshNetdataBadges() {
+      var now = new Date().getTime().toString();
+      $('.netdata-badge').each(function() {
+        this.src = this.src.replace(/\&_=\d*/, '') + '&_=' + now;
+      });
+      setTimeout(refreshNetdataBadges, NETDATA_BADGES_AUTOREFRESH_SECONDS * 1000);
+    }
+    setTimeout(refreshNetdataBadges, NETDATA_BADGES_AUTOREFRESH_SECONDS * 1000);
+</script>
+```
+
+A more advanced badges refresh method is to include `http://your.netdata.ip:19999/refresh-badges.js` in your page.
+
+---
+
+## Escaping URLs
+
+Keep in mind that if you add badge URLs to your HTML pages you have to escape the special characters:
+
+|character|name|escape sequence|
+|:-------:|:--:|:-------------:|
+|``|space (in labels and units)|`%20`|
+|`#`|hash (for colors)|`%23`|
+|`%`|percent (in units)|`%25`|
+|`<`|less than|`%3C`|
+|`>`|greater than|`%3E`|
+|`\`|backslash (when you need a `/`)|`%5C`|
+|`\|`|pipe (delimiting parameters)|`%7C`|
+
+## FAQ
+
+#### Is it fast?
+
+On modern hardware, Netdata can generate about **2.000 badges per second per core**, before noticing any delays. It generates a badge in about half a millisecond!
+
+Of course these timing are for badges that use recent data. If you need badges that do calculations over long durations (a day, or more), timing will differ. Netdata logs its timings at its `access.log`, so take a look there before adding a heavy badge on a busy web site. Of course, you can cache such badges or have a cron job get them from Netdata and save them at your web server at regular intervals.
+
+#### Embedding badges in GitHub
+
+You have 2 options:
+- SVG images with markdown 
+- SVG images with HTML (directly in .md files)
+
+For example, this is the cpu badge shown above:
+
+-   Markdown example:
+
+```md
+[![A nice name](https://registry.my-netdata.io/api/v1/badge.svg?chart=users.cpu&dimensions=root&value_color=grey:null%7Cgreen%3C10%7Cyellow%3C20%7Corange%3C50%7Cblue%3C100%7Cred&label=root%20user%20cpu%20now&units=%25)](https://registry.my-netdata.io/#apps_cpu)
+```
+
+-   HTML example:
+
+```html
+<a href="https://registry.my-netdata.io/#apps_cpu">
+    <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=users.cpu&dimensions=root&value_color=grey:null%7Cgreen%3C10%7Cyellow%3C20%7Corange%3C50%7Cblue%3C100%7Cred&label=root%20user%20cpu%20now&units=%25"></img>
+</a>
+```
+
+Both produce this:
+
+<a href="https://registry.my-netdata.io/#apps_cpu">
+    <img src="https://registry.my-netdata.io/api/v1/badge.svg?chart=users.cpu&dimensions=root&value_color=grey:null%7Cgreen%3C10%7Cyellow%3C20%7Corange%3C50%7Cblue%3C100%7Cred&label=root%20user%20cpu%20now&units=%25"></img>
+</a>
+
+#### Auto-refreshing badges in GitHub
+
+Unfortunately it cannot be done. GitHub fetches all the images using a proxy and rewrites all the URLs to be served by the proxy.
+
+You can refresh them from your browser console though. Press F12 to open the web browser console (switch to the console too), paste the following and press enter. They will refresh:
+
+```js
+var len = document.images.length; while(len--) { document.images[len].src = document.images[len].src.replace(/\?cacheBuster=\d*/, "") + "?cacheBuster=" + new Date().getTime().toString(); };
+```
+
+
diff --git a/src/web/api/v1/api_v1_badge/web_buffer_svg.c b/src/web/api/v1/api_v1_badge/web_buffer_svg.c
new file mode 100644
index 000000000..642261fd3
--- /dev/null
+++ b/src/web/api/v1/api_v1_badge/web_buffer_svg.c
@@ -0,0 +1,1160 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "libnetdata/libnetdata.h"
+#include "../../../server/web_client.h"
+
+#define BADGE_HORIZONTAL_PADDING 4
+#define VERDANA_KERNING 0.2
+#define VERDANA_PADDING 1.0
+
+/*
+ * verdana11_widths[] has been generated with this method:
+ * https://github.com/badges/shields/blob/master/measure-text.js
+*/
+
+static double verdana11_widths[128] = {
+    [0] = 0.0,
+    [1] = 0.0,
+    [2] = 0.0,
+    [3] = 0.0,
+    [4] = 0.0,
+    [5] = 0.0,
+    [6] = 0.0,
+    [7] = 0.0,
+    [8] = 0.0,
+    [9] = 0.0,
+    [10] = 0.0,
+    [11] = 0.0,
+    [12] = 0.0,
+    [13] = 0.0,
+    [14] = 0.0,
+    [15] = 0.0,
+    [16] = 0.0,
+    [17] = 0.0,
+    [18] = 0.0,
+    [19] = 0.0,
+    [20] = 0.0,
+    [21] = 0.0,
+    [22] = 0.0,
+    [23] = 0.0,
+    [24] = 0.0,
+    [25] = 0.0,
+    [26] = 0.0,
+    [27] = 0.0,
+    [28] = 0.0,
+    [29] = 0.0,
+    [30] = 0.0,
+    [31] = 0.0,
+    [32] = 3.8671874999999996, //
+    [33] = 4.3291015625, // !
+    [34] = 5.048828125, // "
+    [35] = 9.001953125, // #
+    [36] = 6.9931640625, // $
+    [37] = 11.837890625, // %
+    [38] = 7.992187499999999, // &
+    [39] = 2.9541015625, // '
+    [40] = 4.9951171875, // (
+    [41] = 4.9951171875, // )
+    [42] = 6.9931640625, // *
+    [43] = 9.001953125, // +
+    [44] = 4.00146484375, // ,
+    [45] = 4.9951171875, // -
+    [46] = 4.00146484375, // .
+    [47] = 4.9951171875, // /
+    [48] = 6.9931640625, // 0
+    [49] = 6.9931640625, // 1
+    [50] = 6.9931640625, // 2
+    [51] = 6.9931640625, // 3
+    [52] = 6.9931640625, // 4
+    [53] = 6.9931640625, // 5
+    [54] = 6.9931640625, // 6
+    [55] = 6.9931640625, // 7
+    [56] = 6.9931640625, // 8
+    [57] = 6.9931640625, // 9
+    [58] = 4.9951171875, // :
+    [59] = 4.9951171875, // ;
+    [60] = 9.001953125, // <
+    [61] = 9.001953125, // =
+    [62] = 9.001953125, // >
+    [63] = 5.99951171875, // ?
+    [64] = 11.0, // @
+    [65] = 7.51953125, // A
+    [66] = 7.541015625, // B
+    [67] = 7.680664062499999, // C
+    [68] = 8.4755859375, // D
+    [69] = 6.95556640625, // E
+    [70] = 6.32177734375, // F
+    [71] = 8.529296875, // G
+    [72] = 8.26611328125, // H
+    [73] = 4.6298828125, // I
+    [74] = 5.00048828125, // J
+    [75] = 7.62158203125, // K
+    [76] = 6.123046875, // L
+    [77] = 9.2705078125, // M
+    [78] = 8.228515625, // N
+    [79] = 8.658203125, // O
+    [80] = 6.63330078125, // P
+    [81] = 8.658203125, // Q
+    [82] = 7.6484375, // R
+    [83] = 7.51953125, // S
+    [84] = 6.7783203125, // T
+    [85] = 8.05126953125, // U
+    [86] = 7.51953125, // V
+    [87] = 10.87646484375, // W
+    [88] = 7.53564453125, // X
+    [89] = 6.767578125, // Y
+    [90] = 7.53564453125, // Z
+    [91] = 4.9951171875, // [
+    [92] = 4.9951171875, // backslash
+    [93] = 4.9951171875, // ]
+    [94] = 9.001953125, // ^
+    [95] = 6.9931640625, // _
+    [96] = 6.9931640625, // `
+    [97] = 6.6064453125, // a
+    [98] = 6.853515625, // b
+    [99] = 5.73095703125, // c
+    [100] = 6.853515625, // d
+    [101] = 6.552734375, // e
+    [102] = 3.8671874999999996, // f
+    [103] = 6.853515625, // g
+    [104] = 6.9609375, // h
+    [105] = 3.0185546875, // i
+    [106] = 3.78662109375, // j
+    [107] = 6.509765625, // k
+    [108] = 3.0185546875, // l
+    [109] = 10.69921875, // m
+    [110] = 6.9609375, // n
+    [111] = 6.67626953125, // o
+    [112] = 6.853515625, // p
+    [113] = 6.853515625, // q
+    [114] = 4.6943359375, // r
+    [115] = 5.73095703125, // s
+    [116] = 4.33447265625, // t
+    [117] = 6.9609375, // u
+    [118] = 6.509765625, // v
+    [119] = 9.001953125, // w
+    [120] = 6.509765625, // x
+    [121] = 6.509765625, // y
+    [122] = 5.779296875, // z
+    [123] = 6.982421875, // {
+    [124] = 4.9951171875, // |
+    [125] = 6.982421875, // }
+    [126] = 9.001953125, // ~
+    [127] = 0.0
+};
+
+// find the width of the string using the verdana 11points font
+static inline double verdana11_width(const char *s, float em_size) {
+    double w = 0.0;
+
+    while(*s) {
+        // if UTF8 multibyte char found and guess it's width equal 1em
+        // as label width will be updated with JavaScript this is not so important
+
+        // TODO: maybe move UTF8 functions from url.c to separate util in libnetdata
+        //       then use url_utf8_get_byte_length etc.
+        if(IS_UTF8_STARTBYTE(*s)) {
+            s++;
+            while(IS_UTF8_BYTE(*s) && !IS_UTF8_STARTBYTE(*s)){
+                s++;
+            }
+            w += em_size;
+        }
+        else {
+            if(likely(!(*s & 0x80))){ // Byte 1XXX XXXX is not valid in UTF8
+            double t = verdana11_widths[(unsigned char)*s];
+                if(t != 0.0)
+                w += t + VERDANA_KERNING;
+            }
+            s++;
+        }
+    }
+
+    w -= VERDANA_KERNING;
+    w += VERDANA_PADDING;
+    return w;
+}
+
+static inline size_t escape_xmlz(char *dst, const char *src, size_t len) {
+    size_t i = len;
+
+    // required escapes from
+    // https://github.com/badges/shields/blob/master/badge.js
+    while(*src && i) {
+        switch(*src) {
+            case '\\':
+                *dst++ = '/';
+                src++;
+                i--;
+                break;
+
+            case '&':
+                if(i > 5) {
+                    strcpy(dst, "&amp;");
+                    i -= 5;
+                    dst += 5;
+                    src++;
+                }
+                else goto cleanup;
+                break;
+
+            case '<':
+                if(i > 4) {
+                    strcpy(dst, "&lt;");
+                    i -= 4;
+                    dst += 4;
+                    src++;
+                }
+                else goto cleanup;
+                break;
+
+            case '>':
+                if(i > 4) {
+                    strcpy(dst, "&gt;");
+                    i -= 4;
+                    dst += 4;
+                    src++;
+                }
+                else goto cleanup;
+                break;
+
+            case '"':
+                if(i > 6) {
+                    strcpy(dst, "&quot;");
+                    i -= 6;
+                    dst += 6;
+                    src++;
+                }
+                else goto cleanup;
+                break;
+
+            case '\'':
+                if(i > 6) {
+                    strcpy(dst, "&apos;");
+                    i -= 6;
+                    dst += 6;
+                    src++;
+                }
+                else goto cleanup;
+                break;
+
+            default:
+                i--;
+                *dst++ = *src++;
+                break;
+        }
+    }
+
+cleanup:
+    *dst = '\0';
+    return len - i;
+}
+
+static inline char *format_value_with_precision_and_unit(char *value_string, size_t value_string_len,
+    NETDATA_DOUBLE value, const char *units, int precision) {
+    if(unlikely(isnan(value) || isinf(value)))
+        value = 0.0;
+
+    char *separator = "";
+    if(unlikely(isalnum((uint8_t)*units)))
+        separator = " ";
+
+    if(precision < 0) {
+        int len, lstop = 0, trim_zeros = 1;
+
+        NETDATA_DOUBLE abs = value;
+        if(isless(value, 0)) {
+            lstop = 1;
+            abs = fabsndd(value);
+        }
+
+        if(isgreaterequal(abs, 1000)) {
+            len = snprintfz(value_string, value_string_len, "%0.0" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+            trim_zeros = 0;
+        }
+        else if(isgreaterequal(abs, 10))     len = snprintfz(value_string, value_string_len, "%0.1" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+        else if(isgreaterequal(abs, 1))      len = snprintfz(value_string, value_string_len, "%0.2" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+        else if(isgreaterequal(abs, 0.1))    len = snprintfz(value_string, value_string_len, "%0.2" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+        else if(isgreaterequal(abs, 0.01))   len = snprintfz(value_string, value_string_len, "%0.4" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+        else if(isgreaterequal(abs, 0.001))  len = snprintfz(value_string, value_string_len, "%0.5" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+        else if(isgreaterequal(abs, 0.0001)) len = snprintfz(value_string, value_string_len, "%0.6" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+        else                                 len = snprintfz(value_string, value_string_len, "%0.7" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
+
+        if(unlikely(trim_zeros)) {
+            int l;
+            // remove trailing zeros from the decimal part
+            for(l = len - 1; l > lstop; l--) {
+                if(likely(value_string[l] == '0')) {
+                    value_string[l] = '\0';
+                    len--;
+                }
+
+                else if(unlikely(value_string[l] == '.')) {
+                    value_string[l] = '\0';
+                    len--;
+                    break;
+                }
+
+                else
+                    break;
+            }
+        }
+
+        if(unlikely(len <= 0)) len = 1;
+        snprintfz(&value_string[len], value_string_len - len, "%s%s", separator, units);
+    }
+    else {
+        if(precision > 50) precision = 50;
+        snprintfz(value_string, value_string_len, "%0.*" NETDATA_DOUBLE_MODIFIER "%s%s", precision, (NETDATA_DOUBLE) value, separator, units);
+    }
+
+    return value_string;
+}
+
+typedef enum badge_units_format {
+    UNITS_FORMAT_NONE,
+    UNITS_FORMAT_SECONDS,
+    UNITS_FORMAT_SECONDS_AGO,
+    UNITS_FORMAT_MINUTES,
+    UNITS_FORMAT_MINUTES_AGO,
+    UNITS_FORMAT_HOURS,
+    UNITS_FORMAT_HOURS_AGO,
+    UNITS_FORMAT_ONOFF,
+    UNITS_FORMAT_UPDOWN,
+    UNITS_FORMAT_OKERROR,
+    UNITS_FORMAT_OKFAILED,
+    UNITS_FORMAT_EMPTY,
+    UNITS_FORMAT_PERCENT
+} UNITS_FORMAT;
+
+
+static struct units_formatter {
+    const char *units;
+    uint32_t hash;
+    UNITS_FORMAT format;
+} badge_units_formatters[] = {
+        { "seconds",     0, UNITS_FORMAT_SECONDS },
+        { "seconds ago", 0, UNITS_FORMAT_SECONDS_AGO },
+        { "minutes",     0, UNITS_FORMAT_MINUTES },
+        { "minutes ago", 0, UNITS_FORMAT_MINUTES_AGO },
+        { "hours",       0, UNITS_FORMAT_HOURS },
+        { "hours ago",   0, UNITS_FORMAT_HOURS_AGO },
+        { "on/off",      0, UNITS_FORMAT_ONOFF },
+        { "on-off",      0, UNITS_FORMAT_ONOFF },
+        { "onoff",       0, UNITS_FORMAT_ONOFF },
+        { "up/down",     0, UNITS_FORMAT_UPDOWN },
+        { "up-down",     0, UNITS_FORMAT_UPDOWN },
+        { "updown",      0, UNITS_FORMAT_UPDOWN },
+        { "ok/error",    0, UNITS_FORMAT_OKERROR },
+        { "ok-error",    0, UNITS_FORMAT_OKERROR },
+        { "okerror",     0, UNITS_FORMAT_OKERROR },
+        { "ok/failed",   0, UNITS_FORMAT_OKFAILED },
+        { "ok-failed",   0, UNITS_FORMAT_OKFAILED },
+        { "okfailed",    0, UNITS_FORMAT_OKFAILED },
+        { "empty",       0, UNITS_FORMAT_EMPTY },
+        { "null",        0, UNITS_FORMAT_EMPTY },
+        { "percentage",  0, UNITS_FORMAT_PERCENT },
+        { "percent",     0, UNITS_FORMAT_PERCENT },
+        { "pcent",       0, UNITS_FORMAT_PERCENT },
+
+        // terminator
+        { NULL,          0, UNITS_FORMAT_NONE }
+};
+
+char *format_value_and_unit(char *value_string, size_t value_string_len,
+    NETDATA_DOUBLE value, const char *units, int precision) {
+    static int max = -1;
+    int i;
+
+    if(unlikely(max == -1)) {
+        for(i = 0; badge_units_formatters[i].units; i++)
+            badge_units_formatters[i].hash = simple_hash(badge_units_formatters[i].units);
+
+        max = i;
+    }
+
+    if(unlikely(!units)) units = "";
+    uint32_t hash_units = simple_hash(units);
+
+    UNITS_FORMAT format = UNITS_FORMAT_NONE;
+    for(i = 0; i < max; i++) {
+        struct units_formatter *ptr = &badge_units_formatters[i];
+
+        if(hash_units == ptr->hash && !strcmp(units, ptr->units)) {
+            format = ptr->format;
+            break;
+        }
+    }
+
+    if(unlikely(format == UNITS_FORMAT_SECONDS || format == UNITS_FORMAT_SECONDS_AGO)) {
+        if(value == 0.0) {
+            snprintfz(value_string, value_string_len, "%s", "now");
+            return value_string;
+        }
+        else if(isnan(value) || isinf(value)) {
+            snprintfz(value_string, value_string_len, "%s", "undefined");
+            return value_string;
+        }
+
+        const char *suffix = (format == UNITS_FORMAT_SECONDS_AGO)?" ago":"";
+
+        size_t s = (size_t)value;
+        size_t d = s / 86400;
+        s = s % 86400;
+
+        size_t h = s / 3600;
+        s = s % 3600;
+
+        size_t m = s / 60;
+        s = s % 60;
+
+        if(d)
+            snprintfz(value_string, value_string_len, "%zu %s %02zu:%02zu:%02zu%s", d, (d == 1)?"day":"days", h, m, s, suffix);
+        else
+            snprintfz(value_string, value_string_len, "%02zu:%02zu:%02zu%s", h, m, s, suffix);
+
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_MINUTES || format == UNITS_FORMAT_MINUTES_AGO)) {
+        if(value == 0.0) {
+            snprintfz(value_string, value_string_len, "%s", "now");
+            return value_string;
+        }
+        else if(isnan(value) || isinf(value)) {
+            snprintfz(value_string, value_string_len, "%s", "undefined");
+            return value_string;
+        }
+
+        const char *suffix = (format == UNITS_FORMAT_MINUTES_AGO)?" ago":"";
+
+        size_t m = (size_t)value;
+        size_t d = m / (60 * 24);
+        m = m % (60 * 24);
+
+        size_t h = m / 60;
+        m = m % 60;
+
+        if(d)
+            snprintfz(value_string, value_string_len, "%zud %02zuh %02zum%s", d, h, m, suffix);
+        else
+            snprintfz(value_string, value_string_len, "%zuh %zum%s", h, m, suffix);
+
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_HOURS || format == UNITS_FORMAT_HOURS_AGO)) {
+        if(value == 0.0) {
+            snprintfz(value_string, value_string_len, "%s", "now");
+            return value_string;
+        }
+        else if(isnan(value) || isinf(value)) {
+            snprintfz(value_string, value_string_len, "%s", "undefined");
+            return value_string;
+        }
+
+        const char *suffix = (format == UNITS_FORMAT_HOURS_AGO)?" ago":"";
+
+        size_t h = (size_t)value;
+        size_t d = h / 24;
+        h = h % 24;
+
+        if(d)
+            snprintfz(value_string, value_string_len, "%zud %zuh%s", d, h, suffix);
+        else
+            snprintfz(value_string, value_string_len, "%zuh%s", h, suffix);
+
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_ONOFF)) {
+        snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"on":"off");
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_UPDOWN)) {
+        snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"up":"down");
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_OKERROR)) {
+        snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"ok":"error");
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_OKFAILED)) {
+        snprintfz(value_string, value_string_len, "%s", (value != 0.0)?"ok":"failed");
+        return value_string;
+    }
+
+    else if(unlikely(format == UNITS_FORMAT_EMPTY))
+        units = "";
+
+    else if(unlikely(format == UNITS_FORMAT_PERCENT))
+        units = "%";
+
+    if(unlikely(isnan(value) || isinf(value))) {
+        strcpy(value_string, "-");
+        return value_string;
+    }
+
+    return format_value_with_precision_and_unit(value_string, value_string_len, value, units, precision);
+}
+
+static struct badge_color {
+    const char *name;
+    uint32_t hash;
+    const char *color;
+} badge_colors[] = {
+
+        // colors from:
+        // https://github.com/badges/shields/blob/master/colorscheme.json
+
+        { "brightgreen", 0, "4c1"    },
+        { "green",       0, "97CA00" },
+        { "yellow",      0, "dfb317" },
+        { "yellowgreen", 0, "a4a61d" },
+        { "orange",      0, "fe7d37" },
+        { "red",         0, "e05d44" },
+        { "blue",        0, "007ec6" },
+        { "grey",        0, "555"    },
+        { "gray",        0, "555"    },
+        { "lightgrey",   0, "9f9f9f" },
+        { "lightgray",   0, "9f9f9f" },
+
+        // terminator
+        { NULL,          0, NULL      }
+};
+
+static inline const char *color_map(const char *color, const char *def) {
+    static int max = -1;
+    int i;
+
+    if(unlikely(max == -1)) {
+        for(i = 0; badge_colors[i].name ;i++)
+            badge_colors[i].hash = simple_hash(badge_colors[i].name);
+
+        max = i;
+    }
+
+    uint32_t hash = simple_hash(color);
+
+    for(i = 0; i < max; i++) {
+        struct badge_color *ptr = &badge_colors[i];
+
+        if(hash == ptr->hash && !strcmp(color, ptr->name))
+            return ptr->color;
+    }
+
+    return def;
+}
+
+typedef enum color_comparison {
+    COLOR_COMPARE_EQUAL,
+    COLOR_COMPARE_NOTEQUAL,
+    COLOR_COMPARE_LESS,
+    COLOR_COMPARE_LESSEQUAL,
+    COLOR_COMPARE_GREATER,
+    COLOR_COMPARE_GREATEREQUAL,
+} BADGE_COLOR_COMPARISON;
+
+static inline void calc_colorz(const char *color, char *final, size_t len, NETDATA_DOUBLE value) {
+    if(isnan(value) || isinf(value))
+        value = NAN;
+
+    char color_buffer[256 + 1] = "";
+    char value_buffer[256 + 1] = "";
+    BADGE_COLOR_COMPARISON comparison = COLOR_COMPARE_GREATER;
+
+    // example input:
+    // color<max|color>min|color:null...
+
+    const char *c = color;
+    while(*c) {
+        char *dc = color_buffer, *dv = NULL;
+        size_t ci = 0, vi = 0;
+
+        const char *t = c;
+
+        while(*t && *t != '|') {
+            switch(*t) {
+                case '!':
+                    if(t[1] == '=') t++;
+                    comparison = COLOR_COMPARE_NOTEQUAL;
+                    dv = value_buffer;
+                    break;
+
+                case '=':
+                case ':':
+                    comparison = COLOR_COMPARE_EQUAL;
+                    dv = value_buffer;
+                    break;
+
+                case '}':
+                case ')':
+                case '>':
+                    if(t[1] == '=') {
+                        comparison = COLOR_COMPARE_GREATEREQUAL;
+                        t++;
+                    }
+                    else
+                        comparison = COLOR_COMPARE_GREATER;
+                    dv = value_buffer;
+                    break;
+
+                case '{':
+                case '(':
+                case '<':
+                    if(t[1] == '=') {
+                        comparison = COLOR_COMPARE_LESSEQUAL;
+                        t++;
+                    }
+                    else if(t[1] == '>' || t[1] == ')' || t[1] == '}') {
+                        comparison = COLOR_COMPARE_NOTEQUAL;
+                        t++;
+                    }
+                    else
+                        comparison = COLOR_COMPARE_LESS;
+                    dv = value_buffer;
+                    break;
+
+                default:
+                    if(dv) {
+                        if(vi < 256) {
+                            vi++;
+                            *dv++ = *t;
+                        }
+                    }
+                    else {
+                        if(ci < 256) {
+                            ci++;
+                            *dc++ = *t;
+                        }
+                    }
+                    break;
+            }
+
+            t++;
+        }
+
+        // prepare for next iteration
+        if(*t == '|') t++;
+        c = t;
+
+        // do the math
+        *dc = '\0';
+        if(dv) {
+            *dv = '\0';
+            NETDATA_DOUBLE v;
+
+            if(!*value_buffer || !strcmp(value_buffer, "null")) {
+                v = NAN;
+            }
+            else {
+                v = str2l(value_buffer);
+                if(isnan(v) || isinf(v))
+                    v = NAN;
+            }
+
+            if(unlikely(isnan(value) || isnan(v))) {
+                if(isnan(value) && isnan(v))
+                    break;
+            }
+            else {
+                     if (unlikely(comparison == COLOR_COMPARE_LESS && isless(value, v))) break;
+                else if (unlikely(comparison == COLOR_COMPARE_LESSEQUAL && islessequal(value, v))) break;
+                else if (unlikely(comparison == COLOR_COMPARE_GREATER && isgreater(value, v))) break;
+                else if (unlikely(comparison == COLOR_COMPARE_GREATEREQUAL && isgreaterequal(value, v))) break;
+                else if (unlikely(comparison == COLOR_COMPARE_EQUAL && !islessgreater(value, v))) break;
+                else if (unlikely(comparison == COLOR_COMPARE_NOTEQUAL && islessgreater(value, v))) break;
+            }
+        }
+        else
+            break;
+    }
+
+    const char *b;
+    if(color_buffer[0])
+        b = color_buffer;
+    else
+        b = color;
+
+    strncpyz(final, b, len);
+}
+
+// value + units
+#define VALUE_STRING_SIZE 100
+
+// label
+#define LABEL_STRING_SIZE 200
+
+// colors
+#define COLOR_STRING_SIZE 100
+
+static inline int allowed_hexa_char(char x) {
+    return ( (x >= '0' && x <= '9') ||
+             (x >= 'a' && x <= 'f') ||
+             (x >= 'A' && x <= 'F')
+           );
+}
+
+static int html_color_check(const char *str) {
+    int i = 0;
+    while(str[i]) {
+        if(!allowed_hexa_char(str[i]))
+            return 0;
+        if(unlikely(i >= 6))
+            return 0;
+        i++;
+    }
+    // want to allow either RGB or RRGGBB
+    return ( i == 6 || i == 3 );
+}
+
+// Will parse color arg as #RRGGBB or #RGB or one of the colors
+// from color_map hash table
+// if parsing fails (argument error) it will return default color
+// given as default parameter (def)
+// in any case it will return either color in "RRGGBB" or "RGB" format as string
+// or whatever is given as def (without checking - caller responsible to give sensible
+// safely escaped default) as default if it fails
+// in any case this function must always return something we can put directly in XML
+// so no escaping is necessary anymore (with exception of default where caller is responsible)
+// to give sensible default
+#define BADGE_SVG_COLOR_ARG_MAXLEN 20
+
+static const char *parse_color_argument(const char *arg, const char *def)
+{
+    if( !arg )
+        return def;
+    size_t len = strnlen(arg, BADGE_SVG_COLOR_ARG_MAXLEN);
+    if( len < 2 || len >= BADGE_SVG_COLOR_ARG_MAXLEN )
+        return def;
+    if( html_color_check(arg) )
+        return arg;
+    return color_map(arg, def);
+}
+
+static void buffer_svg(BUFFER *wb, const char *label,
+    NETDATA_DOUBLE value, const char *units, const char *label_color, const char *value_color, int precision, int scale, uint32_t options, int fixed_width_lbl, int fixed_width_val, const char* text_color_lbl, const char* text_color_val) {
+    char    value_color_buffer[COLOR_STRING_SIZE + 1]
+            , value_string[VALUE_STRING_SIZE + 1]
+            , label_escaped[LABEL_STRING_SIZE + 1]
+            , value_escaped[VALUE_STRING_SIZE + 1];
+
+    const char *label_color_parsed;
+    const char *value_color_parsed;
+
+    double label_width = (double)fixed_width_lbl, value_width = (double)fixed_width_val, total_width;
+    double height = 20.0, font_size = 11.0, text_offset = 5.8, round_corner = 3.0;
+
+    if(scale < 100) scale = 100;
+
+    if(unlikely(!value_color || !*value_color))
+        value_color = (isnan(value) || isinf(value))?"999":"4c1";
+
+    calc_colorz(value_color, value_color_buffer, COLOR_STRING_SIZE, value);
+    format_value_and_unit(value_string, VALUE_STRING_SIZE, (options & RRDR_OPTION_DISPLAY_ABS)? fabsndd(value):value, units, precision);
+
+    if(fixed_width_lbl <= 0 || fixed_width_val <= 0) {
+        label_width = verdana11_width(label, font_size) + (BADGE_HORIZONTAL_PADDING * 2);
+        value_width = verdana11_width(value_string, font_size) + (BADGE_HORIZONTAL_PADDING * 2);
+    }
+    total_width = label_width + value_width;
+
+    escape_xmlz(label_escaped, label, LABEL_STRING_SIZE);
+    escape_xmlz(value_escaped, value_string, VALUE_STRING_SIZE);
+
+    label_color_parsed = parse_color_argument(label_color, "555");
+    value_color_parsed = parse_color_argument(value_color_buffer, "555");
+
+    wb->content_type = CT_IMAGE_SVG_XML;
+
+    total_width  = total_width * scale / 100.0;
+    height       = height      * scale / 100.0;
+    font_size    = font_size   * scale / 100.0;
+    text_offset  = text_offset * scale / 100.0;
+    label_width  = label_width * scale / 100.0;
+    value_width  = value_width * scale / 100.0;
+    round_corner = round_corner * scale / 100.0;
+
+    // svg template from:
+    // https://raw.githubusercontent.com/badges/shields/master/templates/flat-template.svg
+    buffer_sprintf(wb,
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"%0.2f\" height=\"%0.2f\">"
+            "<linearGradient id=\"smooth\" x2=\"0\" y2=\"100%%\">"
+                "<stop offset=\"0\" stop-color=\"#bbb\" stop-opacity=\".1\"/>"
+                "<stop offset=\"1\" stop-opacity=\".1\"/>"
+            "</linearGradient>"
+            "<mask id=\"round\">"
+                "<rect class=\"bdge-ttl-width\" width=\"%0.2f\" height=\"%0.2f\" rx=\"%0.2f\" fill=\"#fff\"/>"
+            "</mask>"
+            "<g mask=\"url(#round)\">"
+                "<rect class=\"bdge-rect-lbl\" width=\"%0.2f\" height=\"%0.2f\" fill=\"#%s\"/>",
+        total_width, height,
+        total_width, height, round_corner,
+        label_width, height, label_color_parsed); //<rect class="bdge-rect-lbl"
+
+    if(fixed_width_lbl > 0 && fixed_width_val > 0) {
+        buffer_sprintf(wb,
+                "<clipPath id=\"lbl-rect\">"
+                    "<rect class=\"bdge-rect-lbl\" width=\"%0.2f\" height=\"%0.2f\"/>"
+                "</clipPath>",
+        label_width, height); //<clipPath id="lbl-rect"> <rect class="bdge-rect-lbl"
+    }
+
+    buffer_sprintf(wb,
+                "<rect class=\"bdge-rect-val\" x=\"%0.2f\" width=\"%0.2f\" height=\"%0.2f\" fill=\"#%s\"/>",
+        label_width, value_width, height, value_color_parsed);
+    
+    if(fixed_width_lbl > 0 && fixed_width_val > 0) {
+        buffer_sprintf(wb,
+                "<clipPath id=\"val-rect\">"
+                    "<rect class=\"bdge-rect-val\" x=\"%0.2f\" width=\"%0.2f\" height=\"%0.2f\"/>"
+                "</clipPath>",
+        label_width, value_width, height);
+    }
+
+    buffer_sprintf(wb,
+                "<rect class=\"bdge-ttl-width\" width=\"%0.2f\" height=\"%0.2f\" fill=\"url(#smooth)\"/>"
+            "</g>"
+            "<g text-anchor=\"middle\" font-family=\"DejaVu Sans,Verdana,Geneva,sans-serif\" font-size=\"%0.2f\">"
+                "<text class=\"bdge-lbl-lbl\" x=\"%0.2f\" y=\"%0.0f\" fill=\"#010101\" fill-opacity=\".3\" clip-path=\"url(#lbl-rect)\">%s</text>"
+                "<text class=\"bdge-lbl-lbl\" x=\"%0.2f\" y=\"%0.0f\" fill=\"#%s\" clip-path=\"url(#lbl-rect)\">%s</text>"
+                "<text class=\"bdge-lbl-val\" x=\"%0.2f\" y=\"%0.0f\" fill=\"#010101\" fill-opacity=\".3\" clip-path=\"url(#val-rect)\">%s</text>"
+                "<text class=\"bdge-lbl-val\" x=\"%0.2f\" y=\"%0.0f\" fill=\"#%s\" clip-path=\"url(#val-rect)\">%s</text>"
+            "</g>",
+        total_width, height,
+        font_size,
+        label_width / 2, ceil(height - text_offset), label_escaped,
+        label_width / 2, ceil(height - text_offset - 1.0), parse_color_argument(text_color_lbl, "fff"), label_escaped,
+        label_width + value_width / 2 -1, ceil(height - text_offset), value_escaped,
+        label_width + value_width / 2 -1, ceil(height - text_offset - 1.0), parse_color_argument(text_color_val, "fff"), value_escaped);
+
+    if(fixed_width_lbl <= 0 || fixed_width_val <= 0){
+        buffer_sprintf(wb,
+            "<script type=\"text/javascript\">"
+                "var bdg_horiz_padding = %d;"
+                "function netdata_bdge_each(list, attr, value){"
+                    "Array.prototype.forEach.call(list, function(el){"
+                        "el.setAttribute(attr, value);"
+                    "});"
+                "};"
+                "var this_svg = document.currentScript.closest(\"svg\");"
+                "var elem_lbl = this_svg.getElementsByClassName(\"bdge-lbl-lbl\");"
+                "var elem_val = this_svg.getElementsByClassName(\"bdge-lbl-val\");"
+                "var lbl_size = elem_lbl[0].getBBox();"
+                "var val_size = elem_val[0].getBBox();"
+                "var width_total = lbl_size.width + bdg_horiz_padding*2;"
+                "this_svg.getElementsByClassName(\"bdge-rect-lbl\")[0].setAttribute(\"width\", width_total);"
+                "netdata_bdge_each(elem_lbl, \"x\", (lbl_size.width / 2) + bdg_horiz_padding);"
+                "netdata_bdge_each(elem_val, \"x\", width_total + (val_size.width / 2) + bdg_horiz_padding);"
+                "var val_rect = this_svg.getElementsByClassName(\"bdge-rect-val\")[0];"
+                "val_rect.setAttribute(\"width\", val_size.width + bdg_horiz_padding*2);"
+                "val_rect.setAttribute(\"x\", width_total);"
+                "width_total += val_size.width + bdg_horiz_padding*2;"
+                "var width_update_elems = this_svg.getElementsByClassName(\"bdge-ttl-width\");"
+                "netdata_bdge_each(width_update_elems, \"width\", width_total);"
+                "this_svg.setAttribute(\"width\", width_total);"
+                "</script>",
+            BADGE_HORIZONTAL_PADDING);
+    }
+    buffer_sprintf(wb, "</svg>");
+}
+
+#define BADGE_URL_ARG_LBL_COLOR "text_color_lbl"
+#define BADGE_URL_ARG_VAL_COLOR "text_color_val"
+
+int api_v1_badge(RRDHOST *host, struct web_client *w, char *url) {
+    int ret = HTTP_RESP_BAD_REQUEST;
+    buffer_flush(w->response.data);
+
+    BUFFER *dimensions = NULL;
+
+    const char *chart = NULL
+    , *before_str = NULL
+    , *after_str = NULL
+    , *points_str = NULL
+    , *multiply_str = NULL
+    , *divide_str = NULL
+    , *label = NULL
+    , *units = NULL
+    , *label_color = NULL
+    , *value_color = NULL
+    , *refresh_str = NULL
+    , *precision_str = NULL
+    , *scale_str = NULL
+    , *alarm = NULL
+    , *fixed_width_lbl_str = NULL
+    , *fixed_width_val_str = NULL
+    , *text_color_lbl_str = NULL
+    , *text_color_val_str = NULL
+    , *group_options = NULL;
+
+    int group = RRDR_GROUPING_AVERAGE;
+    uint32_t options = 0x00000000;
+
+    const RRDCALC_ACQUIRED *rca = NULL;
+    RRDCALC *rc = NULL;
+    RRDSET *st = NULL;
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        netdata_log_debug(D_WEB_CLIENT, "%llu: API v1 badge.svg query param '%s' with value '%s'", w->id, name, value);
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "chart")) chart = value;
+        else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {
+            if(!dimensions)
+                dimensions = buffer_create(100, &netdata_buffers_statistics.buffers_api);
+
+            buffer_strcat(dimensions, "|");
+            buffer_strcat(dimensions, value);
+        }
+        else if(!strcmp(name, "after")) after_str = value;
+        else if(!strcmp(name, "before")) before_str = value;
+        else if(!strcmp(name, "points")) points_str = value;
+        else if(!strcmp(name, "group_options")) group_options = value;
+        else if(!strcmp(name, "group")) {
+            group = time_grouping_parse(value, RRDR_GROUPING_AVERAGE);
+        }
+        else if(!strcmp(name, "options")) {
+            options |= rrdr_options_parse(value);
+        }
+        else if(!strcmp(name, "label")) label = value;
+        else if(!strcmp(name, "units")) units = value;
+        else if(!strcmp(name, "label_color")) label_color = value;
+        else if(!strcmp(name, "value_color")) value_color = value;
+        else if(!strcmp(name, "multiply")) multiply_str = value;
+        else if(!strcmp(name, "divide")) divide_str = value;
+        else if(!strcmp(name, "refresh")) refresh_str = value;
+        else if(!strcmp(name, "precision")) precision_str = value;
+        else if(!strcmp(name, "scale")) scale_str = value;
+        else if(!strcmp(name, "fixed_width_lbl")) fixed_width_lbl_str = value;
+        else if(!strcmp(name, "fixed_width_val")) fixed_width_val_str = value;
+        else if(!strcmp(name, "alarm")) alarm = value;
+        else if(!strcmp(name, BADGE_URL_ARG_LBL_COLOR)) text_color_lbl_str = value;
+        else if(!strcmp(name, BADGE_URL_ARG_VAL_COLOR)) text_color_val_str = value;
+    }
+
+    int fixed_width_lbl = -1;
+    int fixed_width_val = -1;
+
+    if(fixed_width_lbl_str && *fixed_width_lbl_str
+        && fixed_width_val_str && *fixed_width_val_str) {
+        fixed_width_lbl = str2i(fixed_width_lbl_str);
+        fixed_width_val = str2i(fixed_width_val_str);
+    }
+
+    if(!chart || !*chart) {
+        buffer_no_cacheable(w->response.data);
+        buffer_sprintf(w->response.data, "No chart id is given at the request.");
+        goto cleanup;
+    }
+
+    int scale = (scale_str && *scale_str)?str2i(scale_str):100;
+
+    st = rrdset_find(host, chart);
+    if(!st) st = rrdset_find_byname(host, chart);
+    if(!st) {
+        buffer_no_cacheable(w->response.data);
+        buffer_svg(w->response.data, "chart not found", NAN, "", NULL, NULL, -1, scale, 0, -1, -1, NULL, NULL);
+        ret = HTTP_RESP_OK;
+        goto cleanup;
+    }
+    st->last_accessed_time_s = now_realtime_sec();
+
+    if(alarm) {
+        rca = rrdcalc_from_rrdset_get(st, alarm);
+        rc = rrdcalc_acquired_to_rrdcalc(rca);
+
+        if (!rc) {
+            buffer_no_cacheable(w->response.data);
+            buffer_svg(w->response.data, "alarm not found", NAN, "", NULL, NULL, -1, scale, 0, -1, -1, NULL, NULL);
+            ret = HTTP_RESP_OK;
+            goto cleanup;
+        }
+    }
+
+    long long multiply  = (multiply_str  && *multiply_str )?str2l(multiply_str):1;
+    long long divide    = (divide_str    && *divide_str   )?str2l(divide_str):1;
+    long long before    = (before_str    && *before_str   )?str2l(before_str):0;
+    long long after     = (after_str     && *after_str    )?str2l(after_str):-st->update_every;
+    int       points    = (points_str    && *points_str   )?str2i(points_str):1;
+    int       precision = (precision_str && *precision_str)?str2i(precision_str):-1;
+
+    if(!multiply) multiply = 1;
+    if(!divide) divide = 1;
+
+    int refresh = 0;
+    if(refresh_str && *refresh_str) {
+        if(!strcmp(refresh_str, "auto")) {
+            if(rc) refresh = rc->config.update_every;
+            else if(options & RRDR_OPTION_NOT_ALIGNED)
+                refresh = st->update_every;
+            else {
+                refresh = (int)(before - after);
+                if(refresh < 0) refresh = -refresh;
+            }
+        }
+        else {
+            refresh = str2i(refresh_str);
+            if(refresh < 0) refresh = -refresh;
+        }
+    }
+
+    if(!label) {
+        if(alarm) {
+            char *s = (char *)alarm;
+            while(*s) {
+                if(*s == '_') *s = ' ';
+                s++;
+            }
+            label = alarm;
+        }
+        else if(dimensions) {
+            const char *dim = buffer_tostring(dimensions);
+            if(*dim == '|') dim++;
+            label = dim;
+        }
+        else
+            label = rrdset_name(st);
+    }
+    if(!units) {
+        if(alarm) {
+            if(rc->config.units)
+                units = rrdcalc_units(rc);
+            else
+                units = "";
+        }
+        else if(options & RRDR_OPTION_PERCENTAGE)
+            units = "%";
+        else
+            units = rrdset_units(st);
+    }
+
+    netdata_log_debug(D_WEB_CLIENT, "%llu: API command 'badge.svg' for chart '%s', alarm '%s', dimensions '%s', after '%lld', before '%lld', points '%d', group '%d', options '0x%08x'"
+          , w->id
+          , chart
+          , alarm?alarm:""
+          , (dimensions)?buffer_tostring(dimensions):""
+          , after
+          , before
+          , points
+          , group
+          , options
+    );
+
+    if(rc) {
+        if (refresh > 0) {
+            buffer_sprintf(w->response.header, "Refresh: %d\r\n", refresh);
+            w->response.data->date = now_realtime_sec();
+            w->response.data->expires = w->response.data->date + refresh;
+            buffer_cacheable(w->response.data);
+        }
+        else
+            buffer_no_cacheable(w->response.data);
+
+        if(!value_color) {
+            switch(rc->status) {
+                case RRDCALC_STATUS_CRITICAL:
+                    value_color = "red";
+                    break;
+
+                case RRDCALC_STATUS_WARNING:
+                    value_color = "orange";
+                    break;
+
+                case RRDCALC_STATUS_CLEAR:
+                    value_color = "brightgreen";
+                    break;
+
+                case RRDCALC_STATUS_UNDEFINED:
+                    value_color = "lightgrey";
+                    break;
+
+                case RRDCALC_STATUS_UNINITIALIZED:
+                    value_color = "#000";
+                    break;
+
+                default:
+                    value_color = "grey";
+                    break;
+            }
+        }
+
+        buffer_svg(w->response.data,
+                label,
+                (isnan(rc->value)||isinf(rc->value)) ? rc->value : rc->value * multiply / divide,
+                units,
+                label_color,
+                value_color,
+                precision,
+                scale,
+                options,
+                fixed_width_lbl,
+                fixed_width_val,
+                text_color_lbl_str,
+                text_color_val_str
+        );
+        ret = HTTP_RESP_OK;
+    }
+    else {
+        time_t latest_timestamp = 0;
+        int value_is_null = 1;
+        NETDATA_DOUBLE n = NAN;
+        ret = HTTP_RESP_INTERNAL_SERVER_ERROR;
+
+        // if the collected value is too old, don't calculate its value
+        if (rrdset_last_entry_s(st) >= (now_realtime_sec() - (st->update_every * gap_when_lost_iterations_above)))
+            ret = rrdset2value_api_v1(st, w->response.data, &n,
+                                      (dimensions) ? buffer_tostring(dimensions) : NULL,
+                                      points, after, before, group, group_options, 0, options,
+                                      NULL, &latest_timestamp,
+                                      NULL, NULL, NULL,
+                                      &value_is_null, NULL, 0, 0,
+                                      QUERY_SOURCE_API_BADGE, STORAGE_PRIORITY_NORMAL);
+
+        // if the value cannot be calculated, show empty badge
+        if (ret != HTTP_RESP_OK) {
+            buffer_no_cacheable(w->response.data);
+            value_is_null = 1;
+            n = 0;
+            ret = HTTP_RESP_OK;
+        }
+        else if (refresh > 0) {
+            buffer_sprintf(w->response.header, "Refresh: %d\r\n", refresh);
+            w->response.data->expires = now_realtime_sec() + refresh;
+        }
+        else buffer_no_cacheable(w->response.data);
+
+        // render the badge
+        buffer_svg(w->response.data,
+                label,
+                (value_is_null)?NAN:(n * multiply / divide),
+                units,
+                label_color,
+                value_color,
+                precision,
+                scale,
+                options,
+                fixed_width_lbl,
+                fixed_width_val,
+                text_color_lbl_str,
+                text_color_val_str
+        );
+    }
+
+cleanup:
+    rrdcalc_from_rrdset_release(st, rca);
+    buffer_free(dimensions);
+    return ret;
+}
diff --git a/src/web/api/v1/api_v1_calls.h b/src/web/api/v1/api_v1_calls.h
new file mode 100644
index 000000000..36a0605cb
--- /dev/null
+++ b/src/web/api/v1/api_v1_calls.h
@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef NETDATA_API_V1_CALLS_H
+#define NETDATA_API_V1_CALLS_H
+
+#include "../web_api_v1.h"
+
+int api_v1_info(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_config(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_registry(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_manage(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_data(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_chart(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_charts(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_context(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_contexts(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_alarms(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_alarms_values(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_alarm_count(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_alarm_log(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_variable(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_alarm_variables(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_dbengine_stats(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_ml_info(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_aclk(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_functions(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_function(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_metric_correlations(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_weights(RRDHOST *host, struct web_client *w, char *url);
+
+int api_v1_badge(RRDHOST *host, struct web_client *w, char *url);
+int api_v1_allmetrics(RRDHOST *host, struct web_client *w, char *url);
+
+// common library calls
+int api_v1_single_chart_helper(RRDHOST *host, struct web_client *w, char *url, void callback(RRDSET *st, BUFFER *buf));
+void api_v1_management_init(void);
+
+#endif //NETDATA_API_V1_CALLS_H
diff --git a/src/web/api/v1/api_v1_charts.c b/src/web/api/v1/api_v1_charts.c
new file mode 100644
index 000000000..afc67af68
--- /dev/null
+++ b/src/web/api/v1/api_v1_charts.c
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_single_chart_helper(RRDHOST *host, struct web_client *w, char *url, void callback(RRDSET *st, BUFFER *buf)) {
+    int ret = HTTP_RESP_BAD_REQUEST;
+    char *chart = NULL;
+
+    buffer_flush(w->response.data);
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "chart")) chart = value;
+        //else {
+        /// buffer_sprintf(w->response.data, "Unknown parameter '%s' in request.", name);
+        //  goto cleanup;
+        //}
+    }
+
+    if(!chart || !*chart) {
+        buffer_sprintf(w->response.data, "No chart id is given at the request.");
+        goto cleanup;
+    }
+
+    RRDSET *st = rrdset_find(host, chart);
+    if(!st) st = rrdset_find_byname(host, chart);
+    if(!st) {
+        buffer_strcat(w->response.data, "Chart is not found: ");
+        buffer_strcat_htmlescape(w->response.data, chart);
+        ret = HTTP_RESP_NOT_FOUND;
+        goto cleanup;
+    }
+
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    st->last_accessed_time_s = now_realtime_sec();
+    callback(st, w->response.data);
+    return HTTP_RESP_OK;
+
+cleanup:
+    return ret;
+}
+
+int api_v1_charts(RRDHOST *host, struct web_client *w, char *url) {
+    (void)url;
+
+    buffer_flush(w->response.data);
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    charts2json(host, w->response.data);
+    return HTTP_RESP_OK;
+}
+
+int api_v1_chart(RRDHOST *host, struct web_client *w, char *url) {
+    return api_v1_single_chart_helper(host, w, url, rrd_stats_api_v1_chart);
+}
+
diff --git a/src/web/api/v1/api_v1_config.c b/src/web/api/v1/api_v1_config.c
new file mode 100644
index 000000000..69bcde760
--- /dev/null
+++ b/src/web/api/v1/api_v1_config.c
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "web/api/v2/api_v2_calls.h"
+
+int api_v1_config(RRDHOST *host, struct web_client *w, char *url __maybe_unused) {
+    char *action = "tree";
+    char *path = "/";
+    char *id = NULL;
+    char *add_name = NULL;
+    int timeout = 120;
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "action"))
+            action = value;
+        else if(!strcmp(name, "path"))
+            path = value;
+        else if(!strcmp(name, "id"))
+            id = value;
+        else if(!strcmp(name, "name"))
+            add_name = value;
+        else if(!strcmp(name, "timeout")) {
+            timeout = (int)strtol(value, NULL, 10);
+            if(timeout < 10)
+                timeout = 10;
+        }
+    }
+
+    char transaction[UUID_COMPACT_STR_LEN];
+    uuid_unparse_lower_compact(w->transaction, transaction);
+
+    size_t len = strlen(action) + (id ? strlen(id) : 0) + strlen(path) + (add_name ? strlen(add_name) : 0) + 100;
+
+    char cmd[len];
+    if(strcmp(action, "tree") == 0)
+        snprintfz(cmd, sizeof(cmd), PLUGINSD_FUNCTION_CONFIG " tree '%s' '%s'", path, id?id:"");
+    else {
+        DYNCFG_CMDS c = dyncfg_cmds2id(action);
+        if(!id || !*id || !dyncfg_is_valid_id(id)) {
+            rrd_call_function_error(w->response.data, "Invalid id", HTTP_RESP_BAD_REQUEST);
+            return HTTP_RESP_BAD_REQUEST;
+        }
+
+        if(c == DYNCFG_CMD_NONE) {
+            rrd_call_function_error(w->response.data, "Invalid action", HTTP_RESP_BAD_REQUEST);
+            return HTTP_RESP_BAD_REQUEST;
+        }
+
+        if(c == DYNCFG_CMD_ADD || c == DYNCFG_CMD_USERCONFIG || c == DYNCFG_CMD_TEST) {
+            if(c == DYNCFG_CMD_TEST && (!add_name || !*add_name)) {
+                // backwards compatibility for TEST without a name
+                char *colon = strrchr(id, ':');
+                if(colon) {
+                    *colon = '\0';
+                    add_name = ++colon;
+                }
+                else
+                    add_name = "test";
+            }
+
+            if(!add_name || !*add_name || !dyncfg_is_valid_id(add_name)) {
+                rrd_call_function_error(w->response.data, "Invalid name", HTTP_RESP_BAD_REQUEST);
+                return HTTP_RESP_BAD_REQUEST;
+            }
+            snprintfz(cmd, sizeof(cmd), PLUGINSD_FUNCTION_CONFIG " %s %s %s", id, dyncfg_id2cmd_one(c), add_name);
+        }
+        else
+            snprintfz(cmd, sizeof(cmd), PLUGINSD_FUNCTION_CONFIG " %s %s", id, dyncfg_id2cmd_one(c));
+    }
+
+    CLEAN_BUFFER *source = buffer_create(100, NULL);
+    web_client_api_request_vX_source_to_buffer(w, source);
+
+    buffer_flush(w->response.data);
+    int code = rrd_function_run(host, w->response.data, timeout, w->access, cmd,
+                                true, transaction,
+                                NULL, NULL,
+                                web_client_progress_functions_update, w,
+                                web_client_interrupt_callback, w,
+                                w->payload, buffer_tostring(source), false);
+
+    return code;
+}
diff --git a/src/web/api/v1/api_v1_context.c b/src/web/api/v1/api_v1_context.c
new file mode 100644
index 000000000..5b7baf80c
--- /dev/null
+++ b/src/web/api/v1/api_v1_context.c
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_context(RRDHOST *host, struct web_client *w, char *url) {
+    char *context = NULL;
+    RRDCONTEXT_TO_JSON_OPTIONS options = RRDCONTEXT_OPTION_NONE;
+    time_t after = 0, before = 0;
+    const char *chart_label_key = NULL, *chart_labels_filter = NULL;
+    BUFFER *dimensions = NULL;
+
+    buffer_flush(w->response.data);
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "context") || !strcmp(name, "ctx")) context = value;
+        else if(!strcmp(name, "after")) after = str2l(value);
+        else if(!strcmp(name, "before")) before = str2l(value);
+        else if(!strcmp(name, "options")) options = rrdcontext_to_json_parse_options(value);
+        else if(!strcmp(name, "chart_label_key")) chart_label_key = value;
+        else if(!strcmp(name, "chart_labels_filter")) chart_labels_filter = value;
+        else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {
+            if(!dimensions) dimensions = buffer_create(100, &netdata_buffers_statistics.buffers_api);
+            buffer_strcat(dimensions, "|");
+            buffer_strcat(dimensions, value);
+        }
+    }
+
+    if(!context || !*context) {
+        buffer_sprintf(w->response.data, "No context is given at the request.");
+        return HTTP_RESP_BAD_REQUEST;
+    }
+
+    SIMPLE_PATTERN *chart_label_key_pattern = NULL;
+    SIMPLE_PATTERN *chart_labels_filter_pattern = NULL;
+    SIMPLE_PATTERN *chart_dimensions_pattern = NULL;
+
+    if(chart_label_key)
+        chart_label_key_pattern = simple_pattern_create(chart_label_key, ",|\t\r\n\f\v", SIMPLE_PATTERN_EXACT, true);
+
+    if(chart_labels_filter)
+        chart_labels_filter_pattern = simple_pattern_create(chart_labels_filter, ",|\t\r\n\f\v", SIMPLE_PATTERN_EXACT,
+                                                            true);
+
+    if(dimensions) {
+        chart_dimensions_pattern = simple_pattern_create(buffer_tostring(dimensions), ",|\t\r\n\f\v",
+                                                         SIMPLE_PATTERN_EXACT, true);
+        buffer_free(dimensions);
+    }
+
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    int ret = rrdcontext_to_json(host, w->response.data, after, before, options, context, chart_label_key_pattern, chart_labels_filter_pattern, chart_dimensions_pattern);
+
+    simple_pattern_free(chart_label_key_pattern);
+    simple_pattern_free(chart_labels_filter_pattern);
+    simple_pattern_free(chart_dimensions_pattern);
+
+    return ret;
+}
diff --git a/src/web/api/v1/api_v1_contexts.c b/src/web/api/v1/api_v1_contexts.c
new file mode 100644
index 000000000..90d376d47
--- /dev/null
+++ b/src/web/api/v1/api_v1_contexts.c
@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_contexts(RRDHOST *host, struct web_client *w, char *url) {
+    RRDCONTEXT_TO_JSON_OPTIONS options = RRDCONTEXT_OPTION_NONE;
+    time_t after = 0, before = 0;
+    const char *chart_label_key = NULL, *chart_labels_filter = NULL;
+    BUFFER *dimensions = NULL;
+
+    buffer_flush(w->response.data);
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "after")) after = str2l(value);
+        else if(!strcmp(name, "before")) before = str2l(value);
+        else if(!strcmp(name, "options")) options = rrdcontext_to_json_parse_options(value);
+        else if(!strcmp(name, "chart_label_key")) chart_label_key = value;
+        else if(!strcmp(name, "chart_labels_filter")) chart_labels_filter = value;
+        else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {
+            if(!dimensions) dimensions = buffer_create(100, &netdata_buffers_statistics.buffers_api);
+            buffer_strcat(dimensions, "|");
+            buffer_strcat(dimensions, value);
+        }
+    }
+
+    SIMPLE_PATTERN *chart_label_key_pattern = NULL;
+    SIMPLE_PATTERN *chart_labels_filter_pattern = NULL;
+    SIMPLE_PATTERN *chart_dimensions_pattern = NULL;
+
+    if(chart_label_key)
+        chart_label_key_pattern = simple_pattern_create(chart_label_key, ",|\t\r\n\f\v", SIMPLE_PATTERN_EXACT, true);
+
+    if(chart_labels_filter)
+        chart_labels_filter_pattern = simple_pattern_create(chart_labels_filter, ",|\t\r\n\f\v", SIMPLE_PATTERN_EXACT,
+                                                            true);
+
+    if(dimensions) {
+        chart_dimensions_pattern = simple_pattern_create(buffer_tostring(dimensions), ",|\t\r\n\f\v",
+                                                         SIMPLE_PATTERN_EXACT, true);
+        buffer_free(dimensions);
+    }
+
+    w->response.data->content_type = CT_APPLICATION_JSON;
+    int ret = rrdcontexts_to_json(host, w->response.data, after, before, options, chart_label_key_pattern, chart_labels_filter_pattern, chart_dimensions_pattern);
+
+    simple_pattern_free(chart_label_key_pattern);
+    simple_pattern_free(chart_labels_filter_pattern);
+    simple_pattern_free(chart_dimensions_pattern);
+
+    return ret;
+}
diff --git a/src/web/api/v1/api_v1_data.c b/src/web/api/v1/api_v1_data.c
new file mode 100644
index 000000000..30328ed3e
--- /dev/null
+++ b/src/web/api/v1/api_v1_data.c
@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_data(RRDHOST *host, struct web_client *w, char *url) {
+    netdata_log_debug(D_WEB_CLIENT, "%llu: API v1 data with URL '%s'", w->id, url);
+
+    int ret = HTTP_RESP_BAD_REQUEST;
+    BUFFER *dimensions = NULL;
+
+    buffer_flush(w->response.data);
+
+    char    *google_version = "0.6",
+         *google_reqId = "0",
+         *google_sig = "0",
+         *google_out = "json",
+         *responseHandler = NULL,
+         *outFileName = NULL;
+
+    time_t last_timestamp_in_data = 0, google_timestamp = 0;
+
+    char *chart = NULL;
+    char *before_str = NULL;
+    char *after_str = NULL;
+    char *group_time_str = NULL;
+    char *points_str = NULL;
+    char *timeout_str = NULL;
+    char *context = NULL;
+    char *chart_label_key = NULL;
+    char *chart_labels_filter = NULL;
+    char *group_options = NULL;
+    size_t tier = 0;
+    RRDR_TIME_GROUPING group = RRDR_GROUPING_AVERAGE;
+    DATASOURCE_FORMAT format = DATASOURCE_JSON;
+    RRDR_OPTIONS options = 0;
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if(!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if(!name || !*name) continue;
+        if(!value || !*value) continue;
+
+        netdata_log_debug(D_WEB_CLIENT, "%llu: API v1 data query param '%s' with value '%s'", w->id, name, value);
+
+        // name and value are now the parameters
+        // they are not null and not empty
+
+        if(!strcmp(name, "context")) context = value;
+        else if(!strcmp(name, "chart_label_key")) chart_label_key = value;
+        else if(!strcmp(name, "chart_labels_filter")) chart_labels_filter = value;
+        else if(!strcmp(name, "chart")) chart = value;
+        else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {
+            if(!dimensions) dimensions = buffer_create(100, &netdata_buffers_statistics.buffers_api);
+            buffer_strcat(dimensions, "|");
+            buffer_strcat(dimensions, value);
+        }
+        else if(!strcmp(name, "show_dimensions")) options |= RRDR_OPTION_ALL_DIMENSIONS;
+        else if(!strcmp(name, "after")) after_str = value;
+        else if(!strcmp(name, "before")) before_str = value;
+        else if(!strcmp(name, "points")) points_str = value;
+        else if(!strcmp(name, "timeout")) timeout_str = value;
+        else if(!strcmp(name, "gtime")) group_time_str = value;
+        else if(!strcmp(name, "group_options")) group_options = value;
+        else if(!strcmp(name, "group")) {
+            group = time_grouping_parse(value, RRDR_GROUPING_AVERAGE);
+        }
+        else if(!strcmp(name, "format")) {
+            format = datasource_format_str_to_id(value);
+        }
+        else if(!strcmp(name, "options")) {
+            options |= rrdr_options_parse(value);
+        }
+        else if(!strcmp(name, "callback")) {
+            responseHandler = value;
+        }
+        else if(!strcmp(name, "filename")) {
+            outFileName = value;
+        }
+        else if(!strcmp(name, "tqx")) {
+            // parse Google Visualization API options
+            // https://developers.google.com/chart/interactive/docs/dev/implementing_data_source
+            char *tqx_name, *tqx_value;
+
+            while(value) {
+                tqx_value = strsep_skip_consecutive_separators(&value, ";");
+                if(!tqx_value || !*tqx_value) continue;
+
+                tqx_name = strsep_skip_consecutive_separators(&tqx_value, ":");
+                if(!tqx_name || !*tqx_name) continue;
+                if(!tqx_value || !*tqx_value) continue;
+
+                if(!strcmp(tqx_name, "version"))
+                    google_version = tqx_value;
+                else if(!strcmp(tqx_name, "reqId"))
+                    google_reqId = tqx_value;
+                else if(!strcmp(tqx_name, "sig")) {
+                    google_sig = tqx_value;
+                    google_timestamp = strtoul(google_sig, NULL, 0);
+                }
+                else if(!strcmp(tqx_name, "out")) {
+                    google_out = tqx_value;
+                    format = google_data_format_str_to_id(google_out);
+                }
+                else if(!strcmp(tqx_name, "responseHandler"))
+                    responseHandler = tqx_value;
+                else if(!strcmp(tqx_name, "outFileName"))
+                    outFileName = tqx_value;
+            }
+        }
+        else if(!strcmp(name, "tier")) {
+            tier = str2ul(value);
+            if(tier < storage_tiers)
+                options |= RRDR_OPTION_SELECTED_TIER;
+            else
+                tier = 0;
+        }
+    }
+
+    // validate the google parameters given
+    fix_google_param(google_out);
+    fix_google_param(google_sig);
+    fix_google_param(google_reqId);
+    fix_google_param(google_version);
+    fix_google_param(responseHandler);
+    fix_google_param(outFileName);
+
+    RRDSET *st = NULL;
+    ONEWAYALLOC *owa = onewayalloc_create(0);
+    QUERY_TARGET *qt = NULL;
+
+    if(!is_valid_sp(chart) && !is_valid_sp(context)) {
+        buffer_sprintf(w->response.data, "No chart or context is given.");
+        goto cleanup;
+    }
+
+    if(chart && !context) {
+        // check if this is a specific chart
+        st = rrdset_find(host, chart);
+        if (!st) st = rrdset_find_byname(host, chart);
+    }
+
+    long long before = (before_str && *before_str)?str2l(before_str):0;
+    long long after  = (after_str  && *after_str) ?str2l(after_str):-600;
+    int       points = (points_str && *points_str)?str2i(points_str):0;
+    int       timeout = (timeout_str && *timeout_str)?str2i(timeout_str): 0;
+    long      group_time = (group_time_str && *group_time_str)?str2l(group_time_str):0;
+
+    QUERY_TARGET_REQUEST qtr = {
+        .version = 1,
+        .after = after,
+        .before = before,
+        .host = host,
+        .st = st,
+        .nodes = NULL,
+        .contexts = context,
+        .instances = chart,
+        .dimensions = (dimensions)?buffer_tostring(dimensions):NULL,
+        .timeout_ms = timeout,
+        .points = points,
+        .format = format,
+        .options = options,
+        .time_group_method = group,
+        .time_group_options = group_options,
+        .resampling_time = group_time,
+        .tier = tier,
+        .chart_label_key = chart_label_key,
+        .labels = chart_labels_filter,
+        .query_source = QUERY_SOURCE_API_DATA,
+        .priority = STORAGE_PRIORITY_NORMAL,
+        .interrupt_callback = web_client_interrupt_callback,
+        .interrupt_callback_data = w,
+        .transaction = &w->transaction,
+    };
+    qt = query_target_create(&qtr);
+
+    if(!qt || !qt->query.used) {
+        buffer_sprintf(w->response.data, "No metrics where matched to query.");
+        ret = HTTP_RESP_NOT_FOUND;
+        goto cleanup;
+    }
+
+    web_client_timeout_checkpoint_set(w, timeout);
+    if(web_client_timeout_checkpoint_and_check(w, NULL)) {
+        ret = w->response.code;
+        goto cleanup;
+    }
+
+    if(outFileName && *outFileName) {
+        buffer_sprintf(w->response.header, "Content-Disposition: attachment; filename=\"%s\"\r\n", outFileName);
+        netdata_log_debug(D_WEB_CLIENT, "%llu: generating outfilename header: '%s'", w->id, outFileName);
+    }
+
+    if(format == DATASOURCE_DATATABLE_JSONP) {
+        if(responseHandler == NULL)
+            responseHandler = "google.visualization.Query.setResponse";
+
+        netdata_log_debug(D_WEB_CLIENT_ACCESS, "%llu: GOOGLE JSON/JSONP: version = '%s', reqId = '%s', sig = '%s', out = '%s', responseHandler = '%s', outFileName = '%s'",
+                          w->id, google_version, google_reqId, google_sig, google_out, responseHandler, outFileName
+        );
+
+        buffer_sprintf(
+            w->response.data,
+            "%s({version:'%s',reqId:'%s',status:'ok',sig:'%"PRId64"',table:",
+            responseHandler,
+            google_version,
+            google_reqId,
+            (int64_t)(st ? st->last_updated.tv_sec : 0));
+    }
+    else if(format == DATASOURCE_JSONP) {
+        if(responseHandler == NULL)
+            responseHandler = "callback";
+
+        buffer_strcat(w->response.data, responseHandler);
+        buffer_strcat(w->response.data, "(");
+    }
+
+    ret = data_query_execute(owa, w->response.data, qt, &last_timestamp_in_data);
+
+    if(format == DATASOURCE_DATATABLE_JSONP) {
+        if(google_timestamp < last_timestamp_in_data)
+            buffer_strcat(w->response.data, "});");
+
+        else {
+            // the client already has the latest data
+            buffer_flush(w->response.data);
+            buffer_sprintf(w->response.data,
+                           "%s({version:'%s',reqId:'%s',status:'error',errors:[{reason:'not_modified',message:'Data not modified'}]});",
+                           responseHandler, google_version, google_reqId);
+        }
+    }
+    else if(format == DATASOURCE_JSONP)
+        buffer_strcat(w->response.data, ");");
+
+    if(qt->internal.relative)
+        buffer_no_cacheable(w->response.data);
+    else
+        buffer_cacheable(w->response.data);
+
+cleanup:
+    query_target_release(qt);
+    onewayalloc_destroy(owa);
+    buffer_free(dimensions);
+    return ret;
+}
diff --git a/src/web/api/v1/api_v1_dbengine.c b/src/web/api/v1/api_v1_dbengine.c
new file mode 100644
index 000000000..89855f88a
--- /dev/null
+++ b/src/web/api/v1/api_v1_dbengine.c
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+#ifndef ENABLE_DBENGINE
+int web_client_api_request_v1_dbengine_stats(RRDHOST *host __maybe_unused, struct web_client *w __maybe_unused, char *url __maybe_unused) {
+    return HTTP_RESP_NOT_FOUND;
+}
+#else
+static void web_client_api_v1_dbengine_stats_for_tier(BUFFER *wb, size_t tier) {
+    RRDENG_SIZE_STATS stats = rrdeng_size_statistics(multidb_ctx[tier]);
+
+    buffer_sprintf(wb,
+                   "\n\t\t\"default_granularity_secs\":%zu"
+                   ",\n\t\t\"sizeof_datafile\":%zu"
+                   ",\n\t\t\"sizeof_page_in_cache\":%zu"
+                   ",\n\t\t\"sizeof_point_data\":%zu"
+                   ",\n\t\t\"sizeof_page_data\":%zu"
+                   ",\n\t\t\"pages_per_extent\":%zu"
+                   ",\n\t\t\"datafiles\":%zu"
+                   ",\n\t\t\"extents\":%zu"
+                   ",\n\t\t\"extents_pages\":%zu"
+                   ",\n\t\t\"points\":%zu"
+                   ",\n\t\t\"metrics\":%zu"
+                   ",\n\t\t\"metrics_pages\":%zu"
+                   ",\n\t\t\"extents_compressed_bytes\":%zu"
+                   ",\n\t\t\"pages_uncompressed_bytes\":%zu"
+                   ",\n\t\t\"pages_duration_secs\":%lld"
+                   ",\n\t\t\"single_point_pages\":%zu"
+                   ",\n\t\t\"first_t\":%ld"
+                   ",\n\t\t\"last_t\":%ld"
+                   ",\n\t\t\"database_retention_secs\":%lld"
+                   ",\n\t\t\"average_compression_savings\":%0.2f"
+                   ",\n\t\t\"average_point_duration_secs\":%0.2f"
+                   ",\n\t\t\"average_metric_retention_secs\":%0.2f"
+                   ",\n\t\t\"ephemeral_metrics_per_day_percent\":%0.2f"
+                   ",\n\t\t\"average_page_size_bytes\":%0.2f"
+                   ",\n\t\t\"estimated_concurrently_collected_metrics\":%zu"
+                   ",\n\t\t\"currently_collected_metrics\":%zu"
+                   ",\n\t\t\"disk_space\":%zu"
+                   ",\n\t\t\"max_disk_space\":%zu"
+                   , stats.default_granularity_secs
+                   , stats.sizeof_datafile
+                   , stats.sizeof_page_in_cache
+                   , stats.sizeof_point_data
+                   , stats.sizeof_page_data
+                   , stats.pages_per_extent
+                   , stats.datafiles
+                   , stats.extents
+                   , stats.extents_pages
+                   , stats.points
+                   , stats.metrics
+                   , stats.metrics_pages
+                   , stats.extents_compressed_bytes
+                   , stats.pages_uncompressed_bytes
+                   , (long long)stats.pages_duration_secs
+                   , stats.single_point_pages
+                   , stats.first_time_s
+                   , stats.last_time_s
+                   , (long long)stats.database_retention_secs
+                   , stats.average_compression_savings
+                   , stats.average_point_duration_secs
+                   , stats.average_metric_retention_secs
+                   , stats.ephemeral_metrics_per_day_percent
+                   , stats.average_page_size_bytes
+                   , stats.estimated_concurrently_collected_metrics
+                   , stats.currently_collected_metrics
+                   , stats.disk_space
+                   , stats.max_disk_space
+    );
+}
+
+int api_v1_dbengine_stats(RRDHOST *host __maybe_unused, struct web_client *w, char *url __maybe_unused) {
+    if (!netdata_ready)
+        return HTTP_RESP_SERVICE_UNAVAILABLE;
+
+    BUFFER *wb = w->response.data;
+    buffer_flush(wb);
+
+    if(!dbengine_enabled) {
+        buffer_strcat(wb, "dbengine is not enabled");
+        return HTTP_RESP_NOT_FOUND;
+    }
+
+    wb->content_type = CT_APPLICATION_JSON;
+    buffer_no_cacheable(wb);
+    buffer_strcat(wb, "{");
+    for(size_t tier = 0; tier < storage_tiers ;tier++) {
+        buffer_sprintf(wb, "%s\n\t\"tier%zu\": {", tier?",":"", tier);
+        web_client_api_v1_dbengine_stats_for_tier(wb, tier);
+        buffer_strcat(wb, "\n\t}");
+    }
+    buffer_strcat(wb, "\n}");
+
+    return HTTP_RESP_OK;
+}
+#endif
diff --git a/src/web/api/v1/api_v1_function.c b/src/web/api/v1/api_v1_function.c
new file mode 100644
index 000000000..761164fd0
--- /dev/null
+++ b/src/web/api/v1/api_v1_function.c
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_function(RRDHOST *host, struct web_client *w, char *url) {
+    if (!netdata_ready)
+        return HTTP_RESP_SERVICE_UNAVAILABLE;
+
+    int timeout = 0;
+    const char *function = NULL;
+
+    while (url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if (!value || !*value)
+            continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if (!name || !*name)
+            continue;
+
+        if (!strcmp(name, "function"))
+            function = value;
+
+        else if (!strcmp(name, "timeout"))
+            timeout = (int) strtoul(value, NULL, 0);
+    }
+
+    BUFFER *wb = w->response.data;
+    buffer_flush(wb);
+    wb->content_type = CT_APPLICATION_JSON;
+    buffer_no_cacheable(wb);
+
+    char transaction[UUID_COMPACT_STR_LEN];
+    uuid_unparse_lower_compact(w->transaction, transaction);
+
+    CLEAN_BUFFER *source = buffer_create(100, NULL);
+    web_client_api_request_vX_source_to_buffer(w, source);
+
+    return rrd_function_run(host, wb, timeout, w->access, function, true, transaction,
+                            NULL, NULL,
+                            web_client_progress_functions_update, w,
+                            web_client_interrupt_callback, w, w->payload,
+                            buffer_tostring(source), false);
+}
diff --git a/src/web/api/v1/api_v1_functions.c b/src/web/api/v1/api_v1_functions.c
new file mode 100644
index 000000000..bc1c7df8e
--- /dev/null
+++ b/src/web/api/v1/api_v1_functions.c
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_functions(RRDHOST *host, struct web_client *w, char *url __maybe_unused) {
+    if (!netdata_ready)
+        return HTTP_RESP_SERVICE_UNAVAILABLE;
+
+    BUFFER *wb = w->response.data;
+    buffer_flush(wb);
+    wb->content_type = CT_APPLICATION_JSON;
+    buffer_no_cacheable(wb);
+
+    buffer_json_initialize(wb, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_DEFAULT);
+    host_functions2json(host, wb);
+    buffer_json_finalize(wb);
+
+    return HTTP_RESP_OK;
+}
diff --git a/src/web/api/v1/api_v1_info.c b/src/web/api/v1/api_v1_info.c
new file mode 100644
index 000000000..2395cea59
--- /dev/null
+++ b/src/web/api/v1/api_v1_info.c
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+static void host_collectors(RRDHOST *host, BUFFER *wb) {
+    buffer_json_member_add_array(wb, "collectors");
+
+    DICTIONARY *dict = dictionary_create(DICT_OPTION_SINGLE_THREADED|DICT_OPTION_DONT_OVERWRITE_VALUE);
+    RRDSET *st;
+    char name[500];
+
+    time_t now = now_realtime_sec();
+
+    rrdset_foreach_read(st, host) {
+        if (!rrdset_is_available_for_viewers(st))
+            continue;
+
+        sprintf(name, "%s:%s", rrdset_plugin_name(st), rrdset_module_name(st));
+
+        bool old = 0;
+        bool *set = dictionary_set(dict, name, &old, sizeof(bool));
+        if(!*set) {
+            *set = true;
+            st->last_accessed_time_s = now;
+            buffer_json_add_array_item_object(wb);
+            buffer_json_member_add_string(wb, "plugin", rrdset_plugin_name(st));
+            buffer_json_member_add_string(wb, "module", rrdset_module_name(st));
+            buffer_json_object_close(wb);
+        }
+    }
+    rrdset_foreach_done(st);
+    dictionary_destroy(dict);
+
+    buffer_json_array_close(wb);
+}
+
+static inline void web_client_api_request_v1_info_mirrored_hosts_status(BUFFER *wb, RRDHOST *host) {
+    buffer_json_add_array_item_object(wb);
+
+    buffer_json_member_add_string(wb, "hostname", rrdhost_hostname(host));
+    buffer_json_member_add_uint64(wb, "hops", host->system_info ? host->system_info->hops : (host == localhost) ? 0 : 1);
+    buffer_json_member_add_boolean(wb, "reachable", (host == localhost || !rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN)));
+
+    buffer_json_member_add_string(wb, "guid", host->machine_guid);
+    buffer_json_member_add_uuid(wb, "node_id", host->node_id.uuid);
+    CLAIM_ID claim_id = rrdhost_claim_id_get(host);
+    buffer_json_member_add_string(wb, "claim_id", claim_id_is_set(claim_id) ? claim_id.str : NULL);
+
+    buffer_json_object_close(wb);
+}
+
+static inline void web_client_api_request_v1_info_mirrored_hosts(BUFFER *wb) {
+    RRDHOST *host;
+
+    rrd_rdlock();
+
+    buffer_json_member_add_array(wb, "mirrored_hosts");
+    rrdhost_foreach_read(host)
+        buffer_json_add_array_item_string(wb, rrdhost_hostname(host));
+    buffer_json_array_close(wb);
+
+    buffer_json_member_add_array(wb, "mirrored_hosts_status");
+    rrdhost_foreach_read(host) {
+        if ((host == localhost || !rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN))) {
+            web_client_api_request_v1_info_mirrored_hosts_status(wb, host);
+        }
+    }
+    rrdhost_foreach_read(host) {
+        if ((host != localhost && rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN))) {
+            web_client_api_request_v1_info_mirrored_hosts_status(wb, host);
+        }
+    }
+    buffer_json_array_close(wb);
+
+    rrd_rdunlock();
+}
+
+static void web_client_api_request_v1_info_summary_alarm_statuses(RRDHOST *host, BUFFER *wb, const char *key) {
+    buffer_json_member_add_object(wb, key);
+
+    size_t normal = 0, warning = 0, critical = 0;
+    RRDCALC *rc;
+    foreach_rrdcalc_in_rrdhost_read(host, rc) {
+        if(unlikely(!rc->rrdset || !rc->rrdset->last_collected_time.tv_sec))
+            continue;
+
+        switch(rc->status) {
+            case RRDCALC_STATUS_WARNING:
+                warning++;
+                break;
+            case RRDCALC_STATUS_CRITICAL:
+                critical++;
+                break;
+            default:
+                normal++;
+        }
+    }
+    foreach_rrdcalc_in_rrdhost_done(rc);
+
+    buffer_json_member_add_uint64(wb, "normal", normal);
+    buffer_json_member_add_uint64(wb, "warning", warning);
+    buffer_json_member_add_uint64(wb, "critical", critical);
+
+    buffer_json_object_close(wb);
+}
+
+static int web_client_api_request_v1_info_fill_buffer(RRDHOST *host, BUFFER *wb) {
+    buffer_json_initialize(wb, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_DEFAULT);
+
+    buffer_json_member_add_string(wb, "version", rrdhost_program_version(host));
+    buffer_json_member_add_string(wb, "uid", host->machine_guid);
+
+    buffer_json_member_add_uint64(wb, "hosts-available", rrdhost_hosts_available());
+    web_client_api_request_v1_info_mirrored_hosts(wb);
+
+    web_client_api_request_v1_info_summary_alarm_statuses(host, wb, "alarms");
+
+    buffer_json_member_add_string_or_empty(wb, "os_name", host->system_info->host_os_name);
+    buffer_json_member_add_string_or_empty(wb, "os_id", host->system_info->host_os_id);
+    buffer_json_member_add_string_or_empty(wb, "os_id_like", host->system_info->host_os_id_like);
+    buffer_json_member_add_string_or_empty(wb, "os_version", host->system_info->host_os_version);
+    buffer_json_member_add_string_or_empty(wb, "os_version_id", host->system_info->host_os_version_id);
+    buffer_json_member_add_string_or_empty(wb, "os_detection", host->system_info->host_os_detection);
+    buffer_json_member_add_string_or_empty(wb, "cores_total", host->system_info->host_cores);
+    buffer_json_member_add_string_or_empty(wb, "total_disk_space", host->system_info->host_disk_space);
+    buffer_json_member_add_string_or_empty(wb, "cpu_freq", host->system_info->host_cpu_freq);
+    buffer_json_member_add_string_or_empty(wb, "ram_total", host->system_info->host_ram_total);
+
+    buffer_json_member_add_string_or_omit(wb, "container_os_name", host->system_info->container_os_name);
+    buffer_json_member_add_string_or_omit(wb, "container_os_id", host->system_info->container_os_id);
+    buffer_json_member_add_string_or_omit(wb, "container_os_id_like", host->system_info->container_os_id_like);
+    buffer_json_member_add_string_or_omit(wb, "container_os_version", host->system_info->container_os_version);
+    buffer_json_member_add_string_or_omit(wb, "container_os_version_id", host->system_info->container_os_version_id);
+    buffer_json_member_add_string_or_omit(wb, "container_os_detection", host->system_info->container_os_detection);
+    buffer_json_member_add_string_or_omit(wb, "is_k8s_node", host->system_info->is_k8s_node);
+
+    buffer_json_member_add_string_or_empty(wb, "kernel_name", host->system_info->kernel_name);
+    buffer_json_member_add_string_or_empty(wb, "kernel_version", host->system_info->kernel_version);
+    buffer_json_member_add_string_or_empty(wb, "architecture", host->system_info->architecture);
+    buffer_json_member_add_string_or_empty(wb, "virtualization", host->system_info->virtualization);
+    buffer_json_member_add_string_or_empty(wb, "virt_detection", host->system_info->virt_detection);
+    buffer_json_member_add_string_or_empty(wb, "container", host->system_info->container);
+    buffer_json_member_add_string_or_empty(wb, "container_detection", host->system_info->container_detection);
+
+    buffer_json_member_add_string_or_omit(wb, "cloud_provider_type", host->system_info->cloud_provider_type);
+    buffer_json_member_add_string_or_omit(wb, "cloud_instance_type", host->system_info->cloud_instance_type);
+    buffer_json_member_add_string_or_omit(wb, "cloud_instance_region", host->system_info->cloud_instance_region);
+
+    host_labels2json(host, wb, "host_labels");
+    host_functions2json(host, wb);
+    host_collectors(host, wb);
+
+    buffer_json_member_add_boolean(wb, "cloud-enabled", true);
+    buffer_json_member_add_boolean(wb, "cloud-available", true);
+    buffer_json_member_add_boolean(wb, "agent-claimed", is_agent_claimed());
+    buffer_json_member_add_boolean(wb, "aclk-available", aclk_online());
+
+    buffer_json_member_add_string(wb, "memory-mode", rrd_memory_mode_name(host->rrd_memory_mode));
+#ifdef ENABLE_DBENGINE
+    buffer_json_member_add_uint64(wb, "multidb-disk-quota", default_multidb_disk_quota_mb);
+    buffer_json_member_add_uint64(wb, "page-cache-size", default_rrdeng_page_cache_mb);
+#endif // ENABLE_DBENGINE
+    buffer_json_member_add_boolean(wb, "web-enabled", web_server_mode != WEB_SERVER_MODE_NONE);
+    buffer_json_member_add_boolean(wb, "stream-enabled", stream_conf_send_enabled);
+
+    buffer_json_member_add_boolean(wb, "stream-compression",
+                                   host->sender && host->sender->compressor.initialized);
+
+    buffer_json_member_add_boolean(wb, "https-enabled", true);
+
+    buffer_json_member_add_quoted_string(wb, "buildinfo", analytics_data.netdata_buildinfo);
+    buffer_json_member_add_quoted_string(wb, "release-channel", analytics_data.netdata_config_release_channel);
+    buffer_json_member_add_quoted_string(wb, "notification-methods", analytics_data.netdata_notification_methods);
+
+    buffer_json_member_add_boolean(wb, "exporting-enabled", analytics_data.exporting_enabled);
+    buffer_json_member_add_quoted_string(wb, "exporting-connectors", analytics_data.netdata_exporting_connectors);
+
+    buffer_json_member_add_uint64(wb, "allmetrics-prometheus-used", analytics_data.prometheus_hits);
+    buffer_json_member_add_uint64(wb, "allmetrics-shell-used", analytics_data.shell_hits);
+    buffer_json_member_add_uint64(wb, "allmetrics-json-used", analytics_data.json_hits);
+    buffer_json_member_add_uint64(wb, "dashboard-used", analytics_data.dashboard_hits);
+
+    buffer_json_member_add_uint64(wb, "charts-count", analytics_data.charts_count);
+    buffer_json_member_add_uint64(wb, "metrics-count", analytics_data.metrics_count);
+
+#if defined(ENABLE_ML)
+    buffer_json_member_add_object(wb, "ml-info");
+    ml_host_get_info(host, wb);
+    buffer_json_object_close(wb);
+#endif
+
+    buffer_json_finalize(wb);
+    return 0;
+}
+
+int api_v1_info(RRDHOST *host, struct web_client *w, char *url) {
+    (void)url;
+    if (!netdata_ready) return HTTP_RESP_SERVICE_UNAVAILABLE;
+    BUFFER *wb = w->response.data;
+    buffer_flush(wb);
+    wb->content_type = CT_APPLICATION_JSON;
+
+    web_client_api_request_v1_info_fill_buffer(host, wb);
+
+    buffer_no_cacheable(wb);
+    return HTTP_RESP_OK;
+}
diff --git a/src/web/api/v1/api_v1_manage.c b/src/web/api/v1/api_v1_manage.c
new file mode 100644
index 000000000..46611fbf5
--- /dev/null
+++ b/src/web/api/v1/api_v1_manage.c
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+char *api_secret;
+
+static char *get_mgmt_api_key(void) {
+    char filename[FILENAME_MAX + 1];
+    snprintfz(filename, FILENAME_MAX, "%s/netdata.api.key", netdata_configured_varlib_dir);
+    const char *api_key_filename = config_get(CONFIG_SECTION_REGISTRY, "netdata management api key file", filename);
+    static char guid[GUID_LEN + 1] = "";
+
+    if(likely(guid[0]))
+        return guid;
+
+    // read it from disk
+    int fd = open(api_key_filename, O_RDONLY | O_CLOEXEC);
+    if(fd != -1) {
+        char buf[GUID_LEN + 1];
+        if(read(fd, buf, GUID_LEN) != GUID_LEN)
+            netdata_log_error("Failed to read management API key from '%s'", api_key_filename);
+        else {
+            buf[GUID_LEN] = '\0';
+            if(regenerate_guid(buf, guid) == -1) {
+                netdata_log_error("Failed to validate management API key '%s' from '%s'.",
+                                  buf, api_key_filename);
+
+                guid[0] = '\0';
+            }
+        }
+        close(fd);
+    }
+
+    // generate a new one?
+    if(!guid[0]) {
+        nd_uuid_t uuid;
+
+        uuid_generate_time(uuid);
+        uuid_unparse_lower(uuid, guid);
+        guid[GUID_LEN] = '\0';
+
+        // save it
+        fd = open(api_key_filename, O_WRONLY|O_CREAT|O_TRUNC | O_CLOEXEC, 444);
+        if(fd == -1) {
+            netdata_log_error("Cannot create unique management API key file '%s'. Please adjust config parameter 'netdata management api key file' to a proper path and file.", api_key_filename);
+            goto temp_key;
+        }
+
+        if(write(fd, guid, GUID_LEN) != GUID_LEN) {
+            netdata_log_error("Cannot write the unique management API key file '%s'. Please adjust config parameter 'netdata management api key file' to a proper path and file with enough space left.", api_key_filename);
+            close(fd);
+            goto temp_key;
+        }
+
+        close(fd);
+    }
+
+    return guid;
+
+temp_key:
+    netdata_log_info("You can still continue to use the alarm management API using the authorization token %s during this Netdata session only.", guid);
+    return guid;
+}
+
+void api_v1_management_init(void) {
+    api_secret = get_mgmt_api_key();
+}
+
+#define HLT_MGM "manage/health"
+int api_v1_manage(RRDHOST *host, struct web_client *w, char *url) {
+    const char *haystack = buffer_tostring(w->url_path_decoded);
+    char *needle;
+
+    buffer_flush(w->response.data);
+
+    if ((needle = strstr(haystack, HLT_MGM)) == NULL) {
+        buffer_strcat(w->response.data, "Invalid management request. Curently only 'health' is supported.");
+        return HTTP_RESP_NOT_FOUND;
+    }
+    needle += strlen(HLT_MGM);
+    if (*needle != '\0') {
+        buffer_strcat(w->response.data, "Invalid management request. Currently only 'health' is supported.");
+        return HTTP_RESP_NOT_FOUND;
+    }
+    return web_client_api_request_v1_mgmt_health(host, w, url);
+}
diff --git a/src/web/api/v1/api_v1_ml_info.c b/src/web/api/v1/api_v1_ml_info.c
new file mode 100644
index 000000000..121f9bf9c
--- /dev/null
+++ b/src/web/api/v1/api_v1_ml_info.c
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_ml_info(RRDHOST *host, struct web_client *w, char *url) {
+    (void) url;
+#if defined(ENABLE_ML)
+
+    if (!netdata_ready)
+        return HTTP_RESP_SERVICE_UNAVAILABLE;
+
+    BUFFER *wb = w->response.data;
+    buffer_flush(wb);
+    wb->content_type = CT_APPLICATION_JSON;
+
+    buffer_json_initialize(wb, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_DEFAULT);
+    ml_host_get_detection_info(host, wb);
+    buffer_json_finalize(wb);
+
+    buffer_no_cacheable(wb);
+
+    return HTTP_RESP_OK;
+#else
+    UNUSED(host);
+    UNUSED(w);
+    return HTTP_RESP_SERVICE_UNAVAILABLE;
+#endif // ENABLE_ML
+}
diff --git a/src/web/api/v1/api_v1_registry.c b/src/web/api/v1/api_v1_registry.c
new file mode 100644
index 000000000..fa4ce4ca4
--- /dev/null
+++ b/src/web/api/v1/api_v1_registry.c
@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+// Pings a netdata server:
+// /api/v1/registry?action=hello
+//
+// Access to a netdata registry:
+// /api/v1/registry?action=access&machine=${machine_guid}&name=${hostname}&url=${url}
+//
+// Delete from a netdata registry:
+// /api/v1/registry?action=delete&machine=${machine_guid}&name=${hostname}&url=${url}&delete_url=${delete_url}
+//
+// Search for the URLs of a machine:
+// /api/v1/registry?action=search&for=${machine_guid}
+//
+// Impersonate:
+// /api/v1/registry?action=switch&machine=${machine_guid}&name=${hostname}&url=${url}&to=${new_person_guid}
+int api_v1_registry(RRDHOST *host, struct web_client *w, char *url) {
+    static uint32_t hash_action = 0, hash_access = 0, hash_hello = 0, hash_delete = 0, hash_search = 0,
+                    hash_switch = 0, hash_machine = 0, hash_url = 0, hash_name = 0, hash_delete_url = 0, hash_for = 0,
+                    hash_to = 0 /*, hash_redirects = 0 */;
+
+    if(unlikely(!hash_action)) {
+        hash_action = simple_hash("action");
+        hash_access = simple_hash("access");
+        hash_hello = simple_hash("hello");
+        hash_delete = simple_hash("delete");
+        hash_search = simple_hash("search");
+        hash_switch = simple_hash("switch");
+        hash_machine = simple_hash("machine");
+        hash_url = simple_hash("url");
+        hash_name = simple_hash("name");
+        hash_delete_url = simple_hash("delete_url");
+        hash_for = simple_hash("for");
+        hash_to = simple_hash("to");
+        /*
+        hash_redirects = simple_hash("redirects");
+*/
+    }
+
+    netdata_log_debug(D_WEB_CLIENT, "%llu: API v1 registry with URL '%s'", w->id, url);
+
+    // TODO
+    // The browser may send multiple cookies with our id
+
+    char person_guid[UUID_STR_LEN] = "";
+    char *cookie = strstr(w->response.data->buffer, NETDATA_REGISTRY_COOKIE_NAME "=");
+    if(cookie)
+        strncpyz(person_guid, &cookie[sizeof(NETDATA_REGISTRY_COOKIE_NAME)], UUID_STR_LEN - 1);
+    else if(!extract_bearer_token_from_request(w, person_guid, sizeof(person_guid)))
+        person_guid[0] = '\0';
+
+    char action = '\0';
+    char *machine_guid = NULL,
+         *machine_url = NULL,
+         *url_name = NULL,
+         *search_machine_guid = NULL,
+         *delete_url = NULL,
+         *to_person_guid = NULL;
+    /*
+    int redirects = 0;
+*/
+
+    // Don't cache registry responses
+    buffer_no_cacheable(w->response.data);
+
+    while(url) {
+        char *value = strsep_skip_consecutive_separators(&url, "&");
+        if (!value || !*value) continue;
+
+        char *name = strsep_skip_consecutive_separators(&value, "=");
+        if (!name || !*name) continue;
+        if (!value || !*value) continue;
+
+        netdata_log_debug(D_WEB_CLIENT, "%llu: API v1 registry query param '%s' with value '%s'", w->id, name, value);
+
+        uint32_t hash = simple_hash(name);
+
+        if(hash == hash_action && !strcmp(name, "action")) {
+            uint32_t vhash = simple_hash(value);
+
+            if(vhash == hash_access && !strcmp(value, "access")) action = 'A';
+            else if(vhash == hash_hello && !strcmp(value, "hello")) action = 'H';
+            else if(vhash == hash_delete && !strcmp(value, "delete")) action = 'D';
+            else if(vhash == hash_search && !strcmp(value, "search")) action = 'S';
+            else if(vhash == hash_switch && !strcmp(value, "switch")) action = 'W';
+#ifdef NETDATA_INTERNAL_CHECKS
+            else netdata_log_error("unknown registry action '%s'", value);
+#endif /* NETDATA_INTERNAL_CHECKS */
+        }
+        /*
+        else if(hash == hash_redirects && !strcmp(name, "redirects"))
+            redirects = atoi(value);
+*/
+        else if(hash == hash_machine && !strcmp(name, "machine"))
+            machine_guid = value;
+
+        else if(hash == hash_url && !strcmp(name, "url"))
+            machine_url = value;
+
+        else if(action == 'A') {
+            if(hash == hash_name && !strcmp(name, "name"))
+                url_name = value;
+        }
+        else if(action == 'D') {
+            if(hash == hash_delete_url && !strcmp(name, "delete_url"))
+                delete_url = value;
+        }
+        else if(action == 'S') {
+            if(hash == hash_for && !strcmp(name, "for"))
+                search_machine_guid = value;
+        }
+        else if(action == 'W') {
+            if(hash == hash_to && !strcmp(name, "to"))
+                to_person_guid = value;
+        }
+#ifdef NETDATA_INTERNAL_CHECKS
+        else netdata_log_error("unused registry URL parameter '%s' with value '%s'", name, value);
+#endif /* NETDATA_INTERNAL_CHECKS */
+    }
+
+    bool do_not_track = respect_web_browser_do_not_track_policy && web_client_has_donottrack(w);
+
+    if(unlikely(action == 'H')) {
+        // HELLO request, dashboard ACL
+        analytics_log_dashboard();
+        if(unlikely(!http_can_access_dashboard(w)))
+            return web_client_permission_denied_acl(w);
+    }
+    else {
+        // everything else, registry ACL
+        if(unlikely(!http_can_access_registry(w)))
+            return web_client_permission_denied_acl(w);
+
+        if(unlikely(do_not_track)) {
+            buffer_flush(w->response.data);
+            buffer_sprintf(w->response.data, "Your web browser is sending 'DNT: 1' (Do Not Track). The registry requires persistent cookies on your browser to work.");
+            return HTTP_RESP_BAD_REQUEST;
+        }
+    }
+
+    buffer_no_cacheable(w->response.data);
+
+    switch(action) {
+        case 'A':
+            if(unlikely(!machine_guid || !machine_url || !url_name)) {
+                netdata_log_error("Invalid registry request - access requires these parameters: machine ('%s'), url ('%s'), name ('%s')", machine_guid ? machine_guid : "UNSET", machine_url ? machine_url : "UNSET", url_name ? url_name : "UNSET");
+                buffer_flush(w->response.data);
+                buffer_strcat(w->response.data, "Invalid registry Access request.");
+                return HTTP_RESP_BAD_REQUEST;
+            }
+
+            web_client_enable_tracking_required(w);
+            return registry_request_access_json(host, w, person_guid, machine_guid, machine_url, url_name, now_realtime_sec());
+
+        case 'D':
+            if(unlikely(!machine_guid || !machine_url || !delete_url)) {
+                netdata_log_error("Invalid registry request - delete requires these parameters: machine ('%s'), url ('%s'), delete_url ('%s')", machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", delete_url?delete_url:"UNSET");
+                buffer_flush(w->response.data);
+                buffer_strcat(w->response.data, "Invalid registry Delete request.");
+                return HTTP_RESP_BAD_REQUEST;
+            }
+
+            web_client_enable_tracking_required(w);
+            return registry_request_delete_json(host, w, person_guid, machine_guid, machine_url, delete_url, now_realtime_sec());
+
+        case 'S':
+            if(unlikely(!search_machine_guid)) {
+                netdata_log_error("Invalid registry request - search requires these parameters: for ('%s')", search_machine_guid?search_machine_guid:"UNSET");
+                buffer_flush(w->response.data);
+                buffer_strcat(w->response.data, "Invalid registry Search request.");
+                return HTTP_RESP_BAD_REQUEST;
+            }
+
+            web_client_enable_tracking_required(w);
+            return registry_request_search_json(host, w, person_guid, search_machine_guid);
+
+        case 'W':
+            if(unlikely(!machine_guid || !machine_url || !to_person_guid)) {
+                netdata_log_error("Invalid registry request - switching identity requires these parameters: machine ('%s'), url ('%s'), to ('%s')", machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", to_person_guid?to_person_guid:"UNSET");
+                buffer_flush(w->response.data);
+                buffer_strcat(w->response.data, "Invalid registry Switch request.");
+                return HTTP_RESP_BAD_REQUEST;
+            }
+
+            web_client_enable_tracking_required(w);
+            return registry_request_switch_json(host, w, person_guid, machine_guid, machine_url, to_person_guid, now_realtime_sec());
+
+        case 'H':
+            return registry_request_hello_json(host, w, do_not_track);
+
+        default:
+            buffer_flush(w->response.data);
+            buffer_strcat(w->response.data, "Invalid registry request - you need to set an action: hello, access, delete, search");
+            return HTTP_RESP_BAD_REQUEST;
+    }
+}
diff --git a/src/web/api/v1/api_v1_weights.c b/src/web/api/v1/api_v1_weights.c
new file mode 100644
index 000000000..e39fceae1
--- /dev/null
+++ b/src/web/api/v1/api_v1_weights.c
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "api_v1_calls.h"
+
+int api_v1_metric_correlations(RRDHOST *host, struct web_client *w, char *url) {
+    return web_client_api_request_weights(host, w, url, WEIGHTS_METHOD_MC_KS2, WEIGHTS_FORMAT_CHARTS, 1);
+}
+
+int api_v1_weights(RRDHOST *host, struct web_client *w, char *url) {
+    return web_client_api_request_weights(host, w, url, WEIGHTS_METHOD_ANOMALY_RATE, WEIGHTS_FORMAT_CONTEXTS, 1);
+}