Revert "Refactor RRD code. (#15423)" (#15723)

This reverts commit 440bd51e08fdfa2a4daa191fb68643456028a753.

dbengine was still being used for non-zero tiers
even on non-dbengine modes.

14 files changed, 150 insertions, 84 deletions

diff --git a/web/api/badges/web_buffer_svg.c b/web/api/badges/web_buffer_svg.c
index e4f7a37657..9b81ba4fbc 100644
--- a/web/api/badges/web_buffer_svg.c
+++ b/web/api/badges/web_buffer_svg.c
@@ -961,8 +961,8 @@ int web_client_api_request_v1_badge(RRDHOST *host, struct web_client *w, char *u
 
     int scale = (scale_str && *scale_str)?str2i(scale_str):100;
 
-    st = rrdset_find_by_id(host, chart);
-    if(!st) st = rrdset_find_by_name(host, chart);
+    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);
@@ -1113,7 +1113,7 @@ int web_client_api_request_v1_badge(RRDHOST *host, struct web_client *w, char *u
         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 * rrdb.gap_when_lost_iterations_above)))
+        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,
diff --git a/web/api/formatters/charts2json.c b/web/api/formatters/charts2json.c
index 6ee28abee1..2ad068d892 100644
--- a/web/api/formatters/charts2json.c
+++ b/web/api/formatters/charts2json.c
@@ -62,9 +62,9 @@ void charts2json(RRDHOST *host, BUFFER *wb, int skip_volatile, int show_archived
                    , get_release_channel()
                    , rrdhost_os(host)
                    , rrdhost_timezone(host)
-                   , host->update_every
+                   , host->rrd_update_every
                    , host->rrd_history_entries
-                   , storage_engine_name(host->storage_engine_id)
+                   , rrd_memory_mode_name(host->rrd_memory_mode)
                    , custom_dashboard_info_js_filename
     );
 
diff --git a/web/api/formatters/json_wrapper.c b/web/api/formatters/json_wrapper.c
index 113f971403..6a66cbcca6 100644
--- a/web/api/formatters/json_wrapper.c
+++ b/web/api/formatters/json_wrapper.c
@@ -16,7 +16,7 @@ static void jsonwrap_query_metric_plan(BUFFER *wb, QUERY_METRIC *qm) {
     buffer_json_array_close(wb);
 
     buffer_json_member_add_array(wb, "tiers");
-    for (size_t tier = 0; tier < rrdb.storage_tiers; tier++) {
+    for (size_t tier = 0; tier < storage_tiers; tier++) {
         buffer_json_add_array_item_object(wb);
         buffer_json_member_add_uint64(wb, "tr", tier);
         buffer_json_member_add_time_t(wb, "fe", qm->tiers[tier].db_first_time_s);
@@ -920,7 +920,7 @@ void rrdr_json_wrapper_begin(RRDR *r, BUFFER *wb) {
     buffer_json_member_add_string(wb, "format", rrdr_format_to_string(format));
 
     buffer_json_member_add_array(wb, "db_points_per_tier");
-    for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++)
+    for(size_t tier = 0; tier < storage_tiers ; tier++)
         buffer_json_add_array_item_uint64(wb, qt->db.tiers[tier].points);
     buffer_json_array_close(wb);
 
@@ -1269,7 +1269,7 @@ static void query_target_detailed_objects_tree(BUFFER *wb, RRDR *r, RRDR_OPTIONS
 void version_hashes_api_v2(BUFFER *wb, struct query_versions *versions) {
     buffer_json_member_add_object(wb, "versions");
     buffer_json_member_add_uint64(wb, "routing_hard_hash", 1);
-    buffer_json_member_add_uint64(wb, "nodes_hard_hash", dictionary_version(rrdb.rrdhost_root_index));
+    buffer_json_member_add_uint64(wb, "nodes_hard_hash", dictionary_version(rrdhost_root_index));
     buffer_json_member_add_uint64(wb, "contexts_hard_hash", versions->contexts_hard_hash);
     buffer_json_member_add_uint64(wb, "contexts_soft_hash", versions->contexts_soft_hash);
     buffer_json_member_add_uint64(wb, "alerts_hard_hash", versions->alerts_hard_hash);
@@ -1498,7 +1498,7 @@ void rrdr_json_wrapper_end2(RRDR *r, BUFFER *wb) {
 
     buffer_json_member_add_object(wb, "db");
     {
-        buffer_json_member_add_uint64(wb, "tiers", rrdb.storage_tiers);
+        buffer_json_member_add_uint64(wb, "tiers", storage_tiers);
         buffer_json_member_add_time_t(wb, "update_every", qt->db.minimum_latest_update_every_s);
         buffer_json_member_add_time_t(wb, "first_entry", qt->db.first_time_s);
         buffer_json_member_add_time_t(wb, "last_entry", qt->db.last_time_s);
@@ -1513,7 +1513,7 @@ void rrdr_json_wrapper_end2(RRDR *r, BUFFER *wb) {
         buffer_json_object_close(wb); // dimensions
 
         buffer_json_member_add_array(wb, "per_tier");
-        for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++) {
+        for(size_t tier = 0; tier < storage_tiers ; tier++) {
             buffer_json_add_array_item_object(wb);
             buffer_json_member_add_uint64(wb, "tier", tier);
             buffer_json_member_add_uint64(wb, "queries", qt->db.tiers[tier].queries);
diff --git a/web/api/formatters/rrd2json.c b/web/api/formatters/rrd2json.c
index 341437bae5..139fa6ec86 100644
--- a/web/api/formatters/rrd2json.c
+++ b/web/api/formatters/rrd2json.c
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "web/api/web_api_v1.h"
+#include "database/storage_engine.h"
 
 void rrd_stats_api_v1_chart(RRDSET *st, BUFFER *wb) {
     rrdset2json(st, wb, NULL, NULL, 0);
@@ -99,7 +100,7 @@ int rrdset2value_api_v1(
         *db_points_read += r->stats.db_points_read;
 
     if(db_points_per_tier) {
-        for(size_t t = 0; t < rrdb.storage_tiers ;t++)
+        for(size_t t = 0; t < storage_tiers ;t++)
             db_points_per_tier[t] += r->internal.qt->db.tiers[t].points;
     }
 
diff --git a/web/api/formatters/value/value.c b/web/api/formatters/value/value.c
index 6ff8f1b801..1d07f62f6a 100644
--- a/web/api/formatters/value/value.c
+++ b/web/api/formatters/value/value.c
@@ -131,7 +131,7 @@ QUERY_VALUE rrdmetric2value(RRDHOST *host,
             storage_point_merge_to(qv.sp, r->internal.qt->query.array[d].query_points);
         }
 
-        for(size_t t = 0; t < rrdb.storage_tiers ;t++)
+        for(size_t t = 0; t < storage_tiers ;t++)
             qv.storage_points_per_tier[t] = r->internal.qt->db.tiers[t].points;
 
         long i = (!(options & RRDR_OPTION_REVERSED))?(long)rrdr_rows(r) - 1:0;
diff --git a/web/api/health/health_cmdapi.c b/web/api/health/health_cmdapi.c
index 00c34353d1..e8d6845e38 100644
--- a/web/api/health/health_cmdapi.c
+++ b/web/api/health/health_cmdapi.c
@@ -1,4 +1,6 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+//
+// Created by Christopher on 11/12/18.
+//
 
 #include "health_cmdapi.h"
 
diff --git a/web/api/queries/query.c b/web/api/queries/query.c
index d1a7c4b94c..8e1af4d63b 100644
--- a/web/api/queries/query.c
+++ b/web/api/queries/query.c
@@ -946,7 +946,7 @@ static bool query_metric_is_valid_tier(QUERY_METRIC *qm, size_t tier) {
 }
 
 static size_t query_metric_first_working_tier(QUERY_METRIC *qm) {
-    for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++) {
+    for(size_t tier = 0; tier < storage_tiers ; tier++) {
 
         // find the db time-range for this tier for all metrics
         STORAGE_METRIC_HANDLE *db_metric_handle = qm->tiers[tier].db_metric_handle;
@@ -991,7 +991,7 @@ static long query_plan_points_coverage_weight(time_t db_first_time_s, time_t db_
 }
 
 static size_t query_metric_best_tier_for_timeframe(QUERY_METRIC *qm, time_t after_wanted, time_t before_wanted, size_t points_wanted) {
-    if(unlikely(rrdb.storage_tiers < 2))
+    if(unlikely(storage_tiers < 2))
         return 0;
 
     if(unlikely(after_wanted == before_wanted || points_wanted <= 0))
@@ -1004,7 +1004,7 @@ static size_t query_metric_best_tier_for_timeframe(QUERY_METRIC *qm, time_t afte
     time_t min_first_time_s = 0;
     time_t max_last_time_s = 0;
 
-    for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++) {
+    for(size_t tier = 0; tier < storage_tiers ; tier++) {
         time_t first_time_s = qm->tiers[tier].db_first_time_s;
         time_t last_time_s  = qm->tiers[tier].db_last_time_s;
 
@@ -1015,7 +1015,7 @@ static size_t query_metric_best_tier_for_timeframe(QUERY_METRIC *qm, time_t afte
             max_last_time_s = last_time_s;
     }
 
-    for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++) {
+    for(size_t tier = 0; tier < storage_tiers ; tier++) {
 
         // find the db time-range for this tier for all metrics
         STORAGE_METRIC_HANDLE *db_metric_handle = qm->tiers[tier].db_metric_handle;
@@ -1042,7 +1042,7 @@ static size_t query_metric_best_tier_for_timeframe(QUERY_METRIC *qm, time_t afte
     }
 
     size_t best_tier = 0;
-    for(size_t tier = 1; tier < rrdb.storage_tiers ; tier++) {
+    for(size_t tier = 1; tier < storage_tiers ; tier++) {
         if(qm->tiers[tier].weight >= qm->tiers[best_tier].weight)
             best_tier = tier;
     }
@@ -1051,7 +1051,7 @@ static size_t query_metric_best_tier_for_timeframe(QUERY_METRIC *qm, time_t afte
 }
 
 static size_t rrddim_find_best_tier_for_timeframe(QUERY_TARGET *qt, time_t after_wanted, time_t before_wanted, size_t points_wanted) {
-    if(unlikely(rrdb.storage_tiers < 2))
+    if(unlikely(storage_tiers < 2))
         return 0;
 
     if(unlikely(after_wanted == before_wanted || points_wanted <= 0)) {
@@ -1059,9 +1059,9 @@ static size_t rrddim_find_best_tier_for_timeframe(QUERY_TARGET *qt, time_t after
         return 0;
     }
 
-    long weight[rrdb.storage_tiers];
+    long weight[storage_tiers];
 
-    for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++) {
+    for(size_t tier = 0; tier < storage_tiers ; tier++) {
 
         time_t common_first_time_s = 0;
         time_t common_last_time_s = 0;
@@ -1098,7 +1098,7 @@ static size_t rrddim_find_best_tier_for_timeframe(QUERY_TARGET *qt, time_t after
     }
 
     size_t best_tier = 0;
-    for(size_t tier = 1; tier < rrdb.storage_tiers ; tier++) {
+    for(size_t tier = 1; tier < storage_tiers ; tier++) {
         if(weight[tier] >= weight[best_tier])
             best_tier = tier;
     }
@@ -1111,13 +1111,13 @@ static size_t rrddim_find_best_tier_for_timeframe(QUERY_TARGET *qt, time_t after
 
 static time_t rrdset_find_natural_update_every_for_timeframe(QUERY_TARGET *qt, time_t after_wanted, time_t before_wanted, size_t points_wanted, RRDR_OPTIONS options, size_t tier) {
     size_t best_tier;
-    if((options & RRDR_OPTION_SELECTED_TIER) && tier < rrdb.storage_tiers)
+    if((options & RRDR_OPTION_SELECTED_TIER) && tier < storage_tiers)
         best_tier = tier;
     else
         best_tier = rrddim_find_best_tier_for_timeframe(qt, after_wanted, before_wanted, points_wanted);
 
     // find the db minimum update every for this tier for all metrics
-    time_t common_update_every_s = rrdb.default_update_every;
+    time_t common_update_every_s = default_rrd_update_every;
     for(size_t i = 0, used = qt->query.used; i < used ; i++) {
         QUERY_METRIC *qm = query_metric(qt, i);
 
@@ -1260,8 +1260,8 @@ static void query_planer_initialize_plans(QUERY_ENGINE_OPS *ops) {
         ops->r->internal.qt->db.tiers[tier].queries++;
 
         struct query_metric_tier *tier_ptr = &qm->tiers[tier];
-        STORAGE_ENGINE_ID storage_engine_id = query_metric_storage_engine(ops->r->internal.qt, qm, tier);
-        storage_engine_query_init(storage_engine_id, tier_ptr->db_metric_handle, &ops->plans[p].handle,
+        STORAGE_ENGINE *eng = query_metric_storage_engine(ops->r->internal.qt, qm, tier);
+        storage_engine_query_init(eng->backend, tier_ptr->db_metric_handle, &ops->plans[p].handle,
                 after, before, ops->r->internal.qt->request.priority);
 
         ops->plans[p].initialized = true;
@@ -1354,7 +1354,7 @@ static bool query_plan(QUERY_ENGINE_OPS *ops, time_t after_wanted, time_t before
     bool switch_tiers = true;
 
     if((ops->r->internal.qt->window.options & RRDR_OPTION_SELECTED_TIER)
-       && ops->r->internal.qt->window.tier < rrdb.storage_tiers
+       && ops->r->internal.qt->window.tier < storage_tiers
        && query_metric_is_valid_tier(qm, ops->r->internal.qt->window.tier)) {
         selected_tier = ops->r->internal.qt->window.tier;
         switch_tiers = false;
@@ -1383,7 +1383,7 @@ static bool query_plan(QUERY_ENGINE_OPS *ops, time_t after_wanted, time_t before
         // check if our selected tier can start the query
         if (selected_tier_first_time_s > after_wanted) {
             // we need some help from other tiers
-            for (size_t tr = (int)selected_tier + 1; tr < rrdb.storage_tiers && qm->plan.used < QUERY_PLANS_MAX ; tr++) {
+            for (size_t tr = (int)selected_tier + 1; tr < storage_tiers && qm->plan.used < QUERY_PLANS_MAX ; tr++) {
                 if(!query_metric_is_valid_tier(qm, tr))
                     continue;
 
@@ -1940,7 +1940,7 @@ static void rrd2rrdr_query_execute(RRDR *r, size_t dim_id_in_rrdr, QUERY_ENGINE_
 
     r->stats.result_points_generated += points_added;
     r->stats.db_points_read += ops->db_total_points_read;
-    for(size_t tr = 0; tr < rrdb.storage_tiers ; tr++)
+    for(size_t tr = 0; tr < storage_tiers ; tr++)
         qt->db.tiers[tr].points += ops->db_points_read_per_tier[tr];
 }
 
@@ -1950,23 +1950,18 @@ static void rrd2rrdr_query_execute(RRDR *r, size_t dim_id_in_rrdr, QUERY_ENGINE_
 void store_metric_at_tier(RRDDIM *rd, size_t tier, struct rrddim_tier *t, STORAGE_POINT sp, usec_t now_ut);
 
 void rrdr_fill_tier_gap_from_smaller_tiers(RRDDIM *rd, size_t tier, time_t now_s) {
-    if (unlikely(tier >= rrdb.storage_tiers))
-        return;
-    if (rrdb.storage_tiers_backfill[tier] == RRD_BACKFILL_NONE)
-        return;
+    if(unlikely(tier >= storage_tiers)) return;
+    if(storage_tiers_backfill[tier] == RRD_BACKFILL_NONE) return;
 
     struct rrddim_tier *t = &rd->tiers[tier];
-    if (unlikely(!t))
-        return;
+    if(unlikely(!t)) return;
 
-    STORAGE_ENGINE_ID storage_engine_id = rd->rrdset->storage_engine_id;
-    time_t latest_time_s = storage_engine_latest_time_s(storage_engine_id, t->db_metric_handle);
-    time_t granularity = (time_t) rd->rrdset->rrdhost->db[tier].tier_grouping * (time_t)rd->rrdset->update_every;
+    time_t latest_time_s = storage_engine_latest_time_s(t->backend, t->db_metric_handle);
+    time_t granularity = (time_t)t->tier_grouping * (time_t)rd->rrdset->update_every;
     time_t time_diff   = now_s - latest_time_s;
 
     // if the user wants only NEW backfilling, and we don't have any data
-    if (rrdb.storage_tiers_backfill[tier] == RRD_BACKFILL_NEW && latest_time_s <= 0)
-        return;
+    if(storage_tiers_backfill[tier] == RRD_BACKFILL_NEW && latest_time_s <= 0) return;
 
     // there is really nothing we can do
     if(now_s <= latest_time_s || time_diff < granularity) return;
@@ -1975,15 +1970,15 @@ void rrdr_fill_tier_gap_from_smaller_tiers(RRDDIM *rd, size_t tier, time_t now_s
 
     // for each lower tier
     for(int read_tier = (int)tier - 1; read_tier >= 0 ; read_tier--){
-        time_t smaller_tier_first_time = storage_engine_oldest_time_s(storage_engine_id, rd->tiers[read_tier].db_metric_handle);
-        time_t smaller_tier_last_time = storage_engine_latest_time_s(storage_engine_id, rd->tiers[read_tier].db_metric_handle);
+        time_t smaller_tier_first_time = storage_engine_oldest_time_s(rd->tiers[read_tier].backend, rd->tiers[read_tier].db_metric_handle);
+        time_t smaller_tier_last_time = storage_engine_latest_time_s(rd->tiers[read_tier].backend, rd->tiers[read_tier].db_metric_handle);
         if(smaller_tier_last_time <= latest_time_s) continue;  // it is as bad as we are
 
         long after_wanted = (latest_time_s < smaller_tier_first_time) ? smaller_tier_first_time : latest_time_s;
         long before_wanted = smaller_tier_last_time;
 
         struct rrddim_tier *tmp = &rd->tiers[read_tier];
-        storage_engine_query_init(storage_engine_id, tmp->db_metric_handle, &handle, after_wanted, before_wanted, STORAGE_PRIORITY_HIGH);
+        storage_engine_query_init(tmp->backend, tmp->db_metric_handle, &handle, after_wanted, before_wanted, STORAGE_PRIORITY_HIGH);
 
         size_t points_read = 0;
 
@@ -2144,16 +2139,16 @@ bool rrdr_relative_window_to_absolute(time_t *after, time_t *before, time_t *now
     time_t absolute_minimum_time = now - (10 * 365 * 86400);
     time_t absolute_maximum_time = now + (1 * 365 * 86400);
 
-    if (after_requested < absolute_minimum_time && !rrdb.unittest_running)
+    if (after_requested < absolute_minimum_time && !unittest_running)
         after_requested = absolute_minimum_time;
 
-    if (after_requested > absolute_maximum_time && !rrdb.unittest_running)
+    if (after_requested > absolute_maximum_time && !unittest_running)
         after_requested = absolute_maximum_time;
 
-    if (before_requested < absolute_minimum_time && !rrdb.unittest_running)
+    if (before_requested < absolute_minimum_time && !unittest_running)
         before_requested = absolute_minimum_time;
 
-    if (before_requested > absolute_maximum_time && !rrdb.unittest_running)
+    if (before_requested > absolute_maximum_time && !unittest_running)
         before_requested = absolute_maximum_time;
 
     *before = before_requested;
@@ -2291,7 +2286,7 @@ bool query_target_calculate_window(QUERY_TARGET *qt) {
     rrdr_relative_window_to_absolute(&after_wanted, &before_wanted, NULL);
     query_debug_log(":relative2absolute after %ld, before %ld", after_wanted, before_wanted);
 
-    if (natural_points && (options & RRDR_OPTION_SELECTED_TIER) && tier > 0 && rrdb.storage_tiers > 1) {
+    if (natural_points && (options & RRDR_OPTION_SELECTED_TIER) && tier > 0 && storage_tiers > 1) {
         update_every = rrdset_find_natural_update_every_for_timeframe(
                 qt, after_wanted, before_wanted, points_wanted, options, tier);
 
@@ -2354,7 +2349,7 @@ bool query_target_calculate_window(QUERY_TARGET *qt) {
         query_debug_log(":max points_wanted %zu", points_wanted);
     }
 
-    if(points_wanted > 86400 && !rrdb.unittest_running) {
+    if(points_wanted > 86400 && !unittest_running) {
         points_wanted = 86400;
         query_debug_log(":absolute max points_wanted %zu", points_wanted);
     }
@@ -3550,7 +3545,7 @@ RRDR *rrd2rrdr(ONEWAYALLOC *owa, QUERY_TARGET *qt) {
     if(qt->query.used)
         ops = onewayalloc_callocz(owa, qt->query.used, sizeof(QUERY_ENGINE_OPS *));
 
-    size_t capacity = rrdb.libuv_worker_threads * 10;
+    size_t capacity = libuv_worker_threads * 10;
     size_t max_queries_to_prepare = (qt->query.used > (capacity - 1)) ? (capacity - 1) : qt->query.used;
     size_t queries_prepared = 0;
     while(queries_prepared < max_queries_to_prepare) {
diff --git a/web/api/queries/weights.c b/web/api/queries/weights.c
index 3c2e0826e1..26d4555fa7 100644
--- a/web/api/queries/weights.c
+++ b/web/api/queries/weights.c
@@ -149,7 +149,7 @@ static void results_header_to_json(DICTIONARY *results __maybe_unused, BUFFER *w
 
         buffer_json_member_add_array(wb, "db_points_per_tier");
         {
-            for (size_t tier = 0; tier < rrdb.storage_tiers; tier++)
+            for (size_t tier = 0; tier < storage_tiers; tier++)
                 buffer_json_add_array_item_uint64(wb, stats->db_points_per_tier[tier]);
         }
         buffer_json_array_close(wb);
@@ -461,7 +461,7 @@ static void results_header_to_json_v2(DICTIONARY *results __maybe_unused, BUFFER
 
         buffer_json_member_add_array(wb, "db_points_per_tier");
         {
-            for (size_t tier = 0; tier < rrdb.storage_tiers; tier++)
+            for (size_t tier = 0; tier < storage_tiers; tier++)
                 buffer_json_add_array_item_uint64(wb, stats->db_points_per_tier[tier]);
         }
         buffer_json_array_close(wb);
@@ -1288,7 +1288,7 @@ NETDATA_DOUBLE *rrd2rrdr_ks2(
     stats->db_queries++;
     stats->result_points += r->stats.result_points_generated;
     stats->db_points += r->stats.db_points_read;
-    for(size_t tr = 0; tr < rrdb.storage_tiers ; tr++)
+    for(size_t tr = 0; tr < storage_tiers ; tr++)
         stats->db_points_per_tier[tr] += r->internal.qt->db.tiers[tr].points;
 
     if(r->d != 1 || r->internal.qt->query.used != 1) {
@@ -1395,7 +1395,7 @@ static void merge_query_value_to_stats(QUERY_VALUE *qv, WEIGHTS_STATS *stats, si
     stats->db_queries += queries;
     stats->result_points += qv->result_points;
     stats->db_points += qv->points_read;
-    for(size_t tier = 0; tier < rrdb.storage_tiers ; tier++)
+    for(size_t tier = 0; tier < storage_tiers ; tier++)
         stats->db_points_per_tier[tier] += qv->storage_points_per_tier[tier];
 }
 
diff --git a/web/api/web_api.c b/web/api/web_api.c
index de3037736d..e2558b47c9 100644
--- a/web/api/web_api.c
+++ b/web/api/web_api.c
@@ -196,7 +196,7 @@ int web_client_api_request_weights(RRDHOST *host, struct web_client *w, char *ur
 
         else if(!strcmp(name, "tier")) {
             tier = str2ul(value);
-            if(tier < rrdb.storage_tiers)
+            if(tier < storage_tiers)
                 options |= RRDR_OPTION_SELECTED_TIER;
             else
                 tier = 0;
diff --git a/web/api/web_api_v1.c b/web/api/web_api_v1.c
index 066eb37a6e..d730e42d78 100644
--- a/web/api/web_api_v1.c
+++ b/web/api/web_api_v1.c
@@ -494,8 +494,8 @@ inline int web_client_api_request_single_chart(RRDHOST *host, struct web_client
         goto cleanup;
     }
 
-    RRDSET *st = rrdset_find_by_id(host, chart);
-    if(!st) st = rrdset_find_by_name(host, chart);
+    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);
@@ -762,7 +762,7 @@ static inline int web_client_api_request_v1_data(RRDHOST *host, struct web_clien
         }
         else if(!strcmp(name, "tier")) {
             tier = str2ul(value);
-            if(tier < rrdb.storage_tiers)
+            if(tier < storage_tiers)
                 options |= RRDR_OPTION_SELECTED_TIER;
             else
                 tier = 0;
@@ -788,8 +788,8 @@ static inline int web_client_api_request_v1_data(RRDHOST *host, struct web_clien
 
     if(chart && !context) {
         // check if this is a specific chart
-        st = rrdset_find_by_id(host, chart);
-        if (!st) st = rrdset_find_by_name(host, 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;
@@ -1121,8 +1121,8 @@ static inline void web_client_api_request_v1_info_mirrored_hosts_status(BUFFER *
     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 == rrdb.localhost) ? 0 : 1);
-    buffer_json_member_add_boolean(wb, "reachable", (host == rrdb.localhost || !rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN)));
+    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);
@@ -1145,12 +1145,12 @@ static inline void web_client_api_request_v1_info_mirrored_hosts(BUFFER *wb) {
 
     buffer_json_member_add_array(wb, "mirrored_hosts_status");
     rrdhost_foreach_read(host) {
-        if ((host == rrdb.localhost || !rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN))) {
+        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 != rrdb.localhost && rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN))) {
+        if ((host != localhost && rrdhost_flag_check(host, RRDHOST_FLAG_ORPHAN))) {
             web_client_api_request_v1_info_mirrored_hosts_status(wb, host);
         }
     }
@@ -1262,10 +1262,10 @@ inline int web_client_api_request_v1_info_fill_buffer(RRDHOST *host, BUFFER *wb)
     buffer_json_member_add_boolean(wb, "aclk-available", false);
 #endif
 
-    buffer_json_member_add_string(wb, "memory-mode", storage_engine_name(host->storage_engine_id));
+    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", rrdb.default_multidb_disk_quota_mb);
-    buffer_json_member_add_uint64(wb, "page-cache-size", rrdb.default_rrdeng_page_cache_mb);
+    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", default_rrdpush_enabled);
@@ -1436,6 +1436,68 @@ int web_client_api_request_v1_dbengine_stats(RRDHOST *host __maybe_unused, struc
     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 web_client_api_request_v1_dbengine_stats(RRDHOST *host __maybe_unused, struct web_client *w, char *url __maybe_unused) {
     if (!netdata_ready)
         return HTTP_RESP_BACKEND_FETCH_FAILED;
@@ -1443,7 +1505,7 @@ int web_client_api_request_v1_dbengine_stats(RRDHOST *host __maybe_unused, struc
     BUFFER *wb = w->response.data;
     buffer_flush(wb);
 
-    if(!rrdb.dbengine_enabled) {
+    if(!dbengine_enabled) {
         buffer_strcat(wb, "dbengine is not enabled");
         return HTTP_RESP_NOT_FOUND;
     }
@@ -1451,9 +1513,9 @@ int web_client_api_request_v1_dbengine_stats(RRDHOST *host __maybe_unused, struc
     wb->content_type = CT_APPLICATION_JSON;
     buffer_no_cacheable(wb);
     buffer_strcat(wb, "{");
-    for(size_t tier = 0; tier < rrdb.storage_tiers ;tier++) {
+    for(size_t tier = 0; tier < storage_tiers ;tier++) {
         buffer_sprintf(wb, "%s\n\t\"tier%zu\": {", tier?",":"", tier);
-        rrdeng_size_statistics(rrdb.multidb_ctx[tier], wb);
+        web_client_api_v1_dbengine_stats_for_tier(wb, tier);
         buffer_strcat(wb, "\n\t}");
     }
     buffer_strcat(wb, "\n}");
diff --git a/web/api/web_api_v2.c b/web/api/web_api_v2.c
index a38281070c..e9b8d801d0 100644
--- a/web/api/web_api_v2.c
+++ b/web/api/web_api_v2.c
@@ -95,7 +95,7 @@ static bool verify_agent_uuids(const char *machine_guid, const char *node_id, co
     if(!machine_guid || !node_id || !claim_id)
         return false;
 
-    if(strcmp(machine_guid, rrdb.localhost->machine_guid) != 0)
+    if(strcmp(machine_guid, localhost->machine_guid) != 0)
         return false;
 
     char *agent_claim_id = get_agent_claimid();
@@ -103,11 +103,11 @@ static bool verify_agent_uuids(const char *machine_guid, const char *node_id, co
     bool not_verified = (!agent_claim_id || strcmp(claim_id, agent_claim_id) != 0);
     freez(agent_claim_id);
 
-    if (not_verified || !rrdb.localhost->node_id)
+    if(not_verified || !localhost->node_id)
         return false;
 
     char buf[UUID_STR_LEN];
-    uuid_unparse_lower(*rrdb.localhost->node_id, buf);
+    uuid_unparse_lower(*localhost->node_id, buf);
 
     if(strcmp(node_id, buf) != 0)
         return false;
@@ -193,7 +193,7 @@ int api_v2_bearer_token(RRDHOST *host __maybe_unused, struct web_client *w __may
     BUFFER *wb = w->response.data;
     buffer_flush(wb);
     buffer_json_initialize(wb, "\"", "\"", 0, true, false);
-    buffer_json_member_add_string(wb, "mg", rrdb.localhost->machine_guid);
+    buffer_json_member_add_string(wb, "mg", localhost->machine_guid);
     buffer_json_member_add_boolean(wb, "bearer_protection", netdata_is_protected_by_bearer);
     buffer_json_member_add_uuid(wb, "token", &uuid);
     buffer_json_member_add_time_t(wb, "expiration", expires_s);
@@ -521,7 +521,7 @@ static int web_client_api_request_v2_data(RRDHOST *host __maybe_unused, struct w
 
     if(tier_str && *tier_str) {
         tier = str2ul(tier_str);
-        if(tier < rrdb.storage_tiers)
+        if(tier < storage_tiers)
             options |= RRDR_OPTION_SELECTED_TIER;
         else
             tier = 0;
diff --git a/web/server/h2o/http_server.c b/web/server/h2o/http_server.c
index 9abb0ca050..b94a7daeb9 100644
--- a/web/server/h2o/http_server.c
+++ b/web/server/h2o/http_server.c
@@ -235,7 +235,7 @@ static inline int _netdata_uberhandler(h2o_req_t *req, RRDHOST **host)
 static int netdata_uberhandler(h2o_handler_t *self, h2o_req_t *req)
 {
     UNUSED(self);
-    RRDHOST *host = rrdb.localhost;
+    RRDHOST *host = localhost;
 
     int ret = _netdata_uberhandler(req, &host);
 
@@ -249,7 +249,7 @@ static int netdata_uberhandler(h2o_handler_t *self, h2o_req_t *req)
                    ", response: %d",
                    PRINTF_H2O_IOVEC(&req->method),
                    PRINTF_H2O_IOVEC(&req->input.path),
-                   host == rrdb.localhost ? "localhost" : host_uuid_str,
+                   host == localhost ? "localhost" : host_uuid_str,
                    req->res.status);
     } else {
         netdata_log_access("HTTPD %d"
diff --git a/web/server/static/static-threaded.c b/web/server/static/static-threaded.c
index e281885794..b0e691163a 100644
--- a/web/server/static/static-threaded.c
+++ b/web/server/static/static-threaded.c
@@ -438,7 +438,7 @@ void *socket_listen_main_static_threaded