Merging upstream version 1.37.0.

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

53 files changed, 5891 insertions, 2449 deletions

diff --git a/libnetdata/Makefile.am b/libnetdata/Makefile.am
index 5962323e8..1208d16c2 100644
--- a/libnetdata/Makefile.am
+++ b/libnetdata/Makefile.am
@@ -25,6 +25,7 @@ SUBDIRS = \
     socket \
     statistical \
     storage_number \
+    string \
     threads \
     url \
     worker_utilization \
diff --git a/libnetdata/adaptive_resortable_list/adaptive_resortable_list.h b/libnetdata/adaptive_resortable_list/adaptive_resortable_list.h
index 011ee73d9..294c52e81 100644
--- a/libnetdata/adaptive_resortable_list/adaptive_resortable_list.h
+++ b/libnetdata/adaptive_resortable_list/adaptive_resortable_list.h
@@ -64,25 +64,25 @@ typedef struct arl_base {
 } ARL_BASE;
 
 // create a new ARL
-extern ARL_BASE *arl_create(const char *name, void (*processor)(const char *, uint32_t, const char *, void *), size_t rechecks);
+ARL_BASE *arl_create(const char *name, void (*processor)(const char *, uint32_t, const char *, void *), size_t rechecks);
 
 // free an ARL
-extern void arl_free(ARL_BASE *arl_base);
+void arl_free(ARL_BASE *arl_base);
 
 // register an expected keyword to the ARL
 // together with its destination ( i.e. the output of the processor() )
-extern ARL_ENTRY *arl_expect_custom(ARL_BASE *base, const char *keyword, void (*processor)(const char *name, uint32_t hash, const char *value, void *dst), void *dst);
+ARL_ENTRY *arl_expect_custom(ARL_BASE *base, const char *keyword, void (*processor)(const char *name, uint32_t hash, const char *value, void *dst), void *dst);
 #define arl_expect(base, keyword, dst) arl_expect_custom(base, keyword, NULL, dst)
 
 // an internal call to complete the check() call
-extern int arl_find_or_create_and_relink(ARL_BASE *base, const char *s, const char *value);
+int arl_find_or_create_and_relink(ARL_BASE *base, const char *s, const char *value);
 
 // begin an ARL iteration
-extern void arl_begin(ARL_BASE *base);
+void arl_begin(ARL_BASE *base);
 
-extern void arl_callback_str2ull(const char *name, uint32_t hash, const char *value, void *dst);
-extern void arl_callback_str2kernel_uint_t(const char *name, uint32_t hash, const char *value, void *dst);
-extern void arl_callback_ssize_t(const char *name, uint32_t hash, const char *value, void *dst);
+void arl_callback_str2ull(const char *name, uint32_t hash, const char *value, void *dst);
+void arl_callback_str2kernel_uint_t(const char *name, uint32_t hash, const char *value, void *dst);
+void arl_callback_ssize_t(const char *name, uint32_t hash, const char *value, void *dst);
 
 // check a keyword against the ARL
 // this is to be called for each keyword read from source data
diff --git a/libnetdata/arrayalloc/arrayalloc.c b/libnetdata/arrayalloc/arrayalloc.c
index bdf1384d4..f337279ae 100644
--- a/libnetdata/arrayalloc/arrayalloc.c
+++ b/libnetdata/arrayalloc/arrayalloc.c
@@ -6,7 +6,9 @@
 #define ARAL_MAX_PAGE_SIZE_MMAP (1*1024*1024*1024)
 
 // max malloc size
-#define ARAL_MAX_PAGE_SIZE_MALLOC (10*1024*1024)
+// optimal at current versions of libc is up to 256k
+// ideal to have the same overhead as libc is 4k
+#define ARAL_MAX_PAGE_SIZE_MALLOC (64*1024)
 
 typedef struct arrayalloc_free {
     size_t size;
@@ -32,6 +34,33 @@ static inline size_t natural_alignment(size_t size, size_t alignment) {
     return size;
 }
 
+static void arrayalloc_delete_leftover_files(const char *path, const char *required_prefix) {
+    DIR *dir = opendir(path);
+    if(!dir) return;
+
+    char fullpath[FILENAME_MAX + 1];
+    size_t len = strlen(required_prefix);
+
+    struct dirent *de = NULL;
+    while((de = readdir(dir))) {
+        if(de->d_type == DT_DIR)
+            continue;
+
+        if(strncmp(de->d_name, required_prefix, len) != 0)
+            continue;
+
+        snprintfz(fullpath, FILENAME_MAX, "%s/%s", path, de->d_name);
+        info("ARRAYALLOC: removing left-over file '%s'", fullpath);
+        if(unlikely(unlink(fullpath) == -1))
+            error("Cannot delete file '%s'", fullpath);
+    }
+
+    closedir(dir);
+}
+
+// ----------------------------------------------------------------------------
+// arrayalloc_init()
+
 static void arrayalloc_init(ARAL *ar) {
     static netdata_mutex_t mutex = NETDATA_MUTEX_INITIALIZER;
     netdata_mutex_lock(&mutex);
@@ -47,7 +76,7 @@ static void arrayalloc_init(ARAL *ar) {
 
         // we need to add a page pointer after the element
         // so, first align the element size to the pointer size
-        ar->internal.element_size = natural_alignment(ar->element_size, sizeof(uintptr_t));
+        ar->internal.element_size = natural_alignment(ar->requested_element_size, sizeof(uintptr_t));
 
         // then add the size of a pointer to it
         ar->internal.element_size += sizeof(uintptr_t);
@@ -59,18 +88,18 @@ static void arrayalloc_init(ARAL *ar) {
         // and finally align it to the natural alignment
         ar->internal.element_size = natural_alignment(ar->internal.element_size, ARAL_NATURAL_ALIGNMENT);
 
-        // this is where we should write the pointer
+        // we write the page pointer just after each element
         ar->internal.page_ptr_offset = ar->internal.element_size - sizeof(uintptr_t);
 
-        if(ar->element_size + sizeof(uintptr_t) > ar->internal.element_size)
+        if(ar->requested_element_size + sizeof(uintptr_t) > ar->internal.element_size)
             fatal("ARRAYALLOC: failed to calculate properly page_ptr_offset: element size %zu, sizeof(uintptr_t) %zu, natural alignment %zu, final element size %zu, page_ptr_offset %zu",
-                  ar->element_size, sizeof(uintptr_t), ARAL_NATURAL_ALIGNMENT, ar->internal.element_size, ar->internal.page_ptr_offset);
+                  ar->requested_element_size, sizeof(uintptr_t), ARAL_NATURAL_ALIGNMENT, ar->internal.element_size, ar->internal.page_ptr_offset);
 
         //info("ARRAYALLOC: element size %zu, sizeof(uintptr_t) %zu, natural alignment %zu, final element size %zu, page_ptr_offset %zu",
         //      ar->element_size, sizeof(uintptr_t), ARAL_NATURAL_ALIGNMENT, ar->internal.element_size, ar->internal.page_ptr_offset);
 
-        if (ar->elements < 10)
-            ar->elements = 10;
+        if (ar->initial_elements < 10)
+            ar->initial_elements = 10;
 
         ar->internal.mmap = (ar->use_mmap && ar->cache_dir && *ar->cache_dir) ? true : false;
         ar->internal.max_alloc_size = ar->internal.mmap ? ARAL_MAX_PAGE_SIZE_MMAP : ARAL_MAX_PAGE_SIZE_MALLOC;
@@ -81,17 +110,20 @@ static void arrayalloc_init(ARAL *ar) {
         if(ar->internal.max_alloc_size % ar->internal.element_size)
             ar->internal.max_alloc_size -= ar->internal.max_alloc_size % ar->internal.element_size;
 
-        ar->internal.first_page = NULL;
-        ar->internal.last_page = NULL;
+        ar->internal.pages = NULL;
         ar->internal.allocation_multiplier = 1;
         ar->internal.file_number = 0;
 
         if(ar->internal.mmap) {
-            char filename[FILENAME_MAX + 1];
-            snprintfz(filename, FILENAME_MAX, "%s/array_alloc.mmap", *ar->cache_dir);
-            int r = mkdir(filename, 0775);
+            char directory_name[FILENAME_MAX + 1];
+            snprintfz(directory_name, FILENAME_MAX, "%s/array_alloc.mmap", *ar->cache_dir);
+            int r = mkdir(directory_name, 0775);
             if (r != 0 && errno != EEXIST)
-                fatal("Cannot create directory '%s'", filename);
+                fatal("Cannot create directory '%s'", directory_name);
+
+            char filename[FILENAME_MAX + 1];
+            snprintfz(filename, FILENAME_MAX, "%s.", ar->filename);
+            arrayalloc_delete_leftover_files(directory_name, filename);
         }
 
         ar->internal.initialized = true;
@@ -100,8 +132,11 @@ static void arrayalloc_init(ARAL *ar) {
     netdata_mutex_unlock(&mutex);
 }
 
+// ----------------------------------------------------------------------------
+// check a free slot
+
 #ifdef NETDATA_INTERNAL_CHECKS
-static inline void arrayalloc_free_checks(ARAL *ar, ARAL_FREE *fr) {
+static inline void arrayalloc_free_validate_internal_check(ARAL *ar, ARAL_FREE *fr) {
     if(fr->size < ar->internal.element_size)
         fatal("ARRAYALLOC: free item of size %zu, less than the expected element size %zu", fr->size, ar->internal.element_size);
 
@@ -109,65 +144,58 @@ static inline void arrayalloc_free_checks(ARAL *ar, ARAL_FREE *fr) {
         fatal("ARRAYALLOC: free item of size %zu is not multiple to element size %zu", fr->size, ar->internal.element_size);
 }
 #else
-#define arrayalloc_free_checks(ar, fr) debug_dummy()
+#define arrayalloc_free_validate_internal_check(ar, fr) debug_dummy()
 #endif
 
-static inline void unlink_page(ARAL *ar, ARAL_PAGE *page) {
-    if(unlikely(!page)) return;
-
-    if(page->next)
-        page->next->prev = page->prev;
-
-    if(page->prev)
-        page->prev->next = page->next;
-
-    if(page == ar->internal.first_page)
-        ar->internal.first_page = page->next;
-
-    if(page == ar->internal.last_page)
-        ar->internal.last_page = page->prev;
-}
+// ----------------------------------------------------------------------------
+// find the page a pointer belongs to
 
-static inline void link_page_first(ARAL *ar, ARAL_PAGE *page) {
-    page->prev = NULL;
-    page->next = ar->internal.first_page;
-    if(page->next) page->next->prev = page;
+#ifdef NETDATA_INTERNAL_CHECKS
+static inline ARAL_PAGE *find_page_with_allocation_internal_check(ARAL *ar, void *ptr) {
+    uintptr_t seeking = (uintptr_t)ptr;
+    ARAL_PAGE *page;
 
-    ar->internal.first_page = page;
+    for(page = ar->internal.pages; page ; page = page->next) {
+        if(unlikely(seeking >= (uintptr_t)page->data && seeking < (uintptr_t)page->data + page->size))
+            break;
+    }
 
-    if(!ar->internal.last_page)
-        ar->internal.last_page = page;
+    return page;
 }
+#endif
 
-static inline void link_page_last(ARAL *ar, ARAL_PAGE *page) {
-    page->next = NULL;
-    page->prev = ar->internal.last_page;
-    if(page->prev) page->prev->next = page;
-
-    ar->internal.last_page = page;
-
-    if(!ar->internal.first_page)
-        ar->internal.first_page = page;
-}
+// ----------------------------------------------------------------------------
+// find a page with a free slot (there shouldn't be any)
 
-static inline ARAL_PAGE *find_page_with_allocation(ARAL *ar, void *ptr) {
-    uintptr_t seeking = (uintptr_t)ptr;
+#ifdef NETDATA_INTERNAL_CHECKS
+static inline ARAL_PAGE *find_page_with_free_slots_internal_check(ARAL *ar) {
     ARAL_PAGE *page;
 
-    for(page = ar->internal.first_page; page ; page = page->next) {
-        if(unlikely(seeking >= (uintptr_t)page->data && seeking < (uintptr_t)page->data + page->size))
+    for(page = ar->internal.pages; page ; page = page->next) {
+        if(page->free_list)
             break;
+
+        internal_fatal(page->size - page->used_elements * ar->internal.element_size >= ar->internal.element_size,
+                       "ARRAYALLOC: a page is marked full, but it is not!");
+
+        internal_fatal(page->size < page->used_elements * ar->internal.element_size,
+                       "ARRAYALLOC: a page has been overflown!");
     }
 
     return page;
 }
+#endif
 
-static void arrayalloc_increase(ARAL *ar) {
+#ifdef NETDATA_TRACE_ALLOCATIONS
+static void arrayalloc_add_page(ARAL *ar, const char *file, const char *function, size_t line) {
+#else
+static void arrayalloc_add_page(ARAL *ar) {
+#endif
     if(unlikely(!ar->internal.initialized))
         arrayalloc_init(ar);
 
     ARAL_PAGE *page = callocz(1, sizeof(ARAL_PAGE));
-    page->size = ar->elements * ar->internal.element_size * ar->internal.allocation_multiplier;
+    page->size = ar->initial_elements * ar->internal.element_size * ar->internal.allocation_multiplier;
     if(page->size > ar->internal.max_alloc_size)
         page->size = ar->internal.max_alloc_size;
     else
@@ -182,8 +210,13 @@ static void arrayalloc_increase(ARAL *ar) {
         if (unlikely(!page->data))
             fatal("Cannot allocate arrayalloc buffer of size %zu on filename '%s'", page->size, page->filename);
     }
-    else
+    else {
+#ifdef NETDATA_TRACE_ALLOCATIONS
+        page->data = mallocz_int(page->size, file, function, line);
+#else
         page->data = mallocz(page->size);
+#endif
+    }
 
     // link the free space to its page
     ARAL_FREE *fr = (ARAL_FREE *)page->data;
@@ -193,9 +226,9 @@ static void arrayalloc_increase(ARAL *ar) {
     page->free_list = fr;
 
     // link the new page at the front of the list of pages
-    link_page_first(ar, page);
+    DOUBLE_LINKED_LIST_PREPEND_UNSAFE(ar->internal.pages, page, prev, next);
 
-    arrayalloc_free_checks(ar, fr);
+    arrayalloc_free_validate_internal_check(ar, fr);
 }
 
 static void arrayalloc_lock(ARAL *ar) {
@@ -208,63 +241,92 @@ static void arrayalloc_unlock(ARAL *ar) {
         netdata_mutex_unlock(&ar->internal.mutex);
 }
 
-ARAL *arrayalloc_create(size_t element_size, size_t elements, const char *filename, char **cache_dir) {
+ARAL *arrayalloc_create(size_t element_size, size_t elements, const char *filename, char **cache_dir, bool mmap) {
     ARAL *ar = callocz(1, sizeof(ARAL));
-    ar->element_size = element_size;
-    ar->elements = elements;
+    ar->requested_element_size = element_size;
+    ar->initial_elements = elements;
     ar->filename = filename;
     ar->cache_dir = cache_dir;
+    ar->use_mmap = mmap;
     return ar;
 }
 
+#ifdef NETDATA_TRACE_ALLOCATIONS
+void *arrayalloc_mallocz_int(ARAL *ar, const char *file, const char *function, size_t line) {
+#else
 void *arrayalloc_mallocz(ARAL *ar) {
+#endif
+    if(unlikely(!ar->internal.initialized))
+        arrayalloc_init(ar);
+
     arrayalloc_lock(ar);
 
-    if(unlikely(!ar->internal.first_page || !ar->internal.first_page->free_list))
-        arrayalloc_increase(ar);
+    if(unlikely(!ar->internal.pages || !ar->internal.pages->free_list)) {
+            internal_fatal(find_page_with_free_slots_internal_check(ar) != NULL,
+                           "ARRAYALLOC: first page does not have any free slots, but there is another that has!");
 
-    ARAL_PAGE *page = ar->internal.first_page;
-    ARAL_FREE *fr = page->free_list;
+#ifdef NETDATA_TRACE_ALLOCATIONS
+        arrayalloc_add_page(ar, file, function, line);
+#else
+        arrayalloc_add_page(ar);
+#endif
+    }
+
+    ARAL_PAGE *page = ar->internal.pages;
+    ARAL_FREE *found_fr = page->free_list;
 
-    if(unlikely(!fr))
-        fatal("ARRAYALLOC: free item cannot be NULL.");
+    internal_fatal(!found_fr,
+                   "ARRAYALLOC: free item to use, cannot be NULL.");
 
-    if(unlikely(fr->size < ar->internal.element_size))
-        fatal("ARRAYALLOC: free item size %zu is smaller than %zu", fr->size, ar->internal.element_size);
+    internal_fatal(found_fr->size < ar->internal.element_size,
+                   "ARRAYALLOC: free item size %zu, cannot be smaller than %zu",
+                   found_fr->size, ar->internal.element_size);
 
-    if(fr->size - ar->internal.element_size <= ar->internal.element_size) {
-        // we are done with this page
-        page->free_list = NULL;
+    if(unlikely(found_fr->size - ar->internal.element_size < ar->internal.element_size)) {
+        // we can use the entire free space entry
 
-        if(page != ar->internal.last_page) {
-            unlink_page(ar, page);
-            link_page_last(ar, page);
+        page->free_list = found_fr->next;
+
+        if(unlikely(!page->free_list)) {
+            // we are done with this page
+            // move the full page last
+            // so that pages with free items remain first in the list
+            DOUBLE_LINKED_LIST_REMOVE_UNSAFE(ar->internal.pages, page, prev, next);
+            DOUBLE_LINKED_LIST_APPEND_UNSAFE(ar->internal.pages, page, prev, next);
         }
     }
     else {
-        uint8_t *data = (uint8_t *)fr;
-        ARAL_FREE *fr2 = (ARAL_FREE *)&data[ar->internal.element_size];
-        fr2->page = fr->page;
-        fr2->size = fr->size - ar->internal.element_size;
-        fr2->next = fr->next;
-        page->free_list = fr2;
-
-        arrayalloc_free_checks(ar, fr2);
+        // we can split the free space entry
+
+        uint8_t *data = (uint8_t *)found_fr;
+        ARAL_FREE *fr = (ARAL_FREE *)&data[ar->internal.element_size];
+        fr->page = page;
+        fr->size = found_fr->size - ar->internal.element_size;
+
+        // link the free slot first in the page
+        fr->next = found_fr->next;
+        page->free_list = fr;
+
+        arrayalloc_free_validate_internal_check(ar, fr);
     }
 
-    fr->page->used_elements++;
+    page->used_elements++;
 
     // put the page pointer after the element
-    uint8_t *data = (uint8_t *)fr;
+    uint8_t *data = (uint8_t *)found_fr;
     ARAL_PAGE **page_ptr = (ARAL_PAGE **)&data[ar->internal.page_ptr_offset];
     *page_ptr = page;
 
     arrayalloc_unlock(ar);
-    return (void *)fr;
+    return (void *)found_fr;
 }
 
+#ifdef NETDATA_TRACE_ALLOCATIONS
+void arrayalloc_freez_int(ARAL *ar, void *ptr, const char *file, const char *function, size_t line) {
+#else
 void arrayalloc_freez(ARAL *ar, void *ptr) {
-    if(!ptr) return;
+#endif
+    if(unlikely(!ptr)) return;
     arrayalloc_lock(ar);
 
     // get the page pointer
@@ -282,10 +344,10 @@ void arrayalloc_freez(ARAL *ar, void *ptr) {
 #endif
     }
 
-#ifdef NETDATA_INTERNAL_CHECKS
+#ifdef NETDATA_ARRAYALLOC_INTERNAL_CHECKS
     {
         // find the page ptr belongs
-        ARAL_PAGE *page2 = find_page_with_allocation(ar, ptr);
+        ARAL_PAGE *page2 = find_page_with_allocation_internal_check(ar, ptr);
 
         if(unlikely(page != page2))
             fatal("ARRAYALLOC: page pointers do not match!");
@@ -312,24 +374,116 @@ void arrayalloc_freez(ARAL *ar, void *ptr) {
 
     // if the page is empty, release it
     if(!page->used_elements) {
-        unlink_page(ar, page);
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(ar->internal.pages, page, prev, next);
 
         // free it
         if(ar->internal.mmap) {
-            munmap(page->data, page->size);
+            netdata_munmap(page->data, page->size);
             if (unlikely(unlink(page->filename) == 1))
                 error("Cannot delete file '%s'", page->filename);
             freez((void *)page->filename);
         }
-        else
+        else {
+#ifdef NETDATA_TRACE_ALLOCATIONS
+            freez_int(page->data, file, function, line);
+#else
             freez(page->data);
+#endif
+        }
 
         freez(page);
     }
-    else if(page != ar->internal.first_page) {
-        unlink_page(ar, page);
-        link_page_first(ar, page);
+    else if(page != ar->internal.pages) {
+        // move the page with free item first
+        // so that the next allocation will use this page
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(ar->internal.pages, page, prev, next);
+        DOUBLE_LINKED_LIST_PREPEND_UNSAFE(ar->internal.pages, page, prev, next);
     }
 
     arrayalloc_unlock(ar);
 }
+
+int aral_unittest(size_t elements) {
+    char *cache_dir = "/tmp/";
+    ARAL *ar = arrayalloc_create(20, 10, "test-aral", &cache_dir, false);
+
+    void *pointers[elements];
+
+    for(size_t i = 0; i < elements ;i++) {
+        pointers[i] = arrayalloc_mallocz(ar);
+    }
+
+    for(size_t div = 5; div >= 2 ;div--) {
+        for (size_t i = 0; i < elements / div; i++) {
+            arrayalloc_freez(ar, pointers[i]);
+        }
+
+        for (size_t i = 0; i < elements / div; i++) {
+            pointers[i] = arrayalloc_mallocz(ar);
+        }
+    }
+
+    for(size_t step = 50; step >= 10 ;step -= 10) {
+        for (size_t i = 0; i < elements; i += step) {
+            arrayalloc_freez(ar, pointers[i]);
+        }
+
+        for (size_t i = 0; i < elements; i += step) {
+            pointers[i] = arrayalloc_mallocz(ar);
+        }
+    }
+
+    for(size_t i = 0; i < elements ;i++) {
+        arrayalloc_freez(ar, pointers[i]);
+    }
+
+    if(ar->internal.pages) {
+        fprintf(stderr, "ARAL leftovers detected (1)");
+        return 1;
+    }
+
+    size_t ops = 0;
+    size_t increment = elements / 10;
+    size_t allocated = 0;
+    for(size_t all = increment; all <= elements ; all += increment) {
+
+        for(; allocated < all ; allocated++) {
+            pointers[allocated] = arrayalloc_mallocz(ar);
+            ops++;
+        }
+
+        size_t to_free = now_realtime_usec() % all;
+        size_t free_list[to_free];
+        for(size_t i = 0; i < to_free ;i++) {
+            size_t pos;
+            do {
+                pos = now_realtime_usec() % all;
+            } while(!pointers[pos]);
+
+            arrayalloc_freez(ar, pointers[pos]);
+            pointers[pos] = NULL;
+            free_list[i] = pos;
+            ops++;
+        }
+
+        for(size_t i = 0; i < to_free ;i++) {
+            size_t pos = free_list[i];
+            pointers[pos] = arrayalloc_mallocz(ar);
+            ops++;
+        }
+    }
+
+    for(size_t i = 0; i < allocated - 1 ;i++) {
+        arrayalloc_freez(ar, pointers[i]);
+        ops++;
+    }
+
+    arrayalloc_freez(ar, pointers[allocated - 1]);
+
+    if(ar->internal.pages) {
+        fprintf(stderr, "ARAL leftovers detected (2)");
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/libnetdata/arrayalloc/arrayalloc.h b/libnetdata/arrayalloc/arrayalloc.h
index e0e9e7f9f..cf80b73fd 100644
--- a/libnetdata/arrayalloc/arrayalloc.h
+++ b/libnetdata/arrayalloc/arrayalloc.h
@@ -5,8 +5,8 @@
 #include "../libnetdata.h"
 
 typedef struct arrayalloc {
-    size_t element_size;
-    size_t elements;
+    size_t requested_element_size;
+    size_t initial_elements;
     const char *filename;
     char **cache_dir;
     bool use_mmap;
@@ -23,13 +23,26 @@ typedef struct arrayalloc {
         size_t allocation_multiplier;
         size_t max_alloc_size;
         netdata_mutex_t mutex;
-        struct arrayalloc_page *first_page;
-        struct arrayalloc_page *last_page;
+        struct arrayalloc_page *pages;
     } internal;
 } ARAL;
 
-extern ARAL *arrayalloc_create(size_t element_size, size_t elements, const char *filename, char **cache_dir);
-extern void *arrayalloc_mallocz(ARAL *ar);
-extern void arrayalloc_freez(ARAL *ar, void *ptr);
+ARAL *arrayalloc_create(size_t element_size, size_t elements, const char *filename, char **cache_dir, bool mmap);
+int aral_unittest(size_t elements);
+
+#ifdef NETDATA_TRACE_ALLOCATIONS
+
+#define arrayalloc_mallocz(ar) arrayalloc_mallocz_int(ar, __FILE__, __FUNCTION__, __LINE__)
+#define arrayalloc_freez(ar, ptr) arrayalloc_freez_int(ar, ptr, __FILE__, __FUNCTION__, __LINE__)
+
+void *arrayalloc_mallocz_int(ARAL *ar, const char *file, const char *function, size_t line);
+void arrayalloc_freez_int(ARAL *ar, void *ptr, const char *file, const char *function, size_t line);
+
+#else // NETDATA_TRACE_ALLOCATIONS
+
+void *arrayalloc_mallocz(ARAL *ar);
+void arrayalloc_freez(ARAL *ar, void *ptr);
+
+#endif // NETDATA_TRACE_ALLOCATIONS
 
 #endif // ARRAYALLOC_H
diff --git a/libnetdata/buffer/buffer.c b/libnetdata/buffer/buffer.c
index 8a32184f6..d0940588f 100644
--- a/libnetdata/buffer/buffer.c
+++ b/libnetdata/buffer/buffer.c
@@ -136,6 +136,66 @@ void buffer_print_llu(BUFFER *wb, unsigned long long uvalue)
     wb->len += wstr - str;
 }
 
+void buffer_print_ll(BUFFER *wb, long long value)
+{
+    buffer_need_bytes(wb, 50);
+
+    if(value < 0) {
+        buffer_fast_strcat(wb, "-", 1);
+        value = -value;
+    }
+
+    buffer_print_llu(wb, value);
+}
+
+static unsigned char bits03_to_hex[16] = {
+    [0] = '0',
+    [1] = '1',
+    [2] = '2',
+    [3] = '3',
+    [4] = '4',
+    [5] = '5',
+    [6] = '6',
+    [7] = '7',
+    [8] = '8',
+    [9] = '9',
+    [10] = 'A',
+    [11] = 'B',
+    [12] = 'C',
+    [13] = 'D',
+    [14] = 'E',
+    [15] = 'F'
+};
+
+void buffer_print_llu_hex(BUFFER *wb, unsigned long long value)
+{
+    unsigned char buffer[sizeof(unsigned long long) * 2 + 2 + 1];   // 8 bytes * 2 + '0x' + '\0'
+    unsigned char *e = &buffer[sizeof(unsigned long long) * 2 + 2];
+    unsigned char *p = e;
+
+    *p-- = '\0';
+    *p-- = bits03_to_hex[value & 0xF];
+    value >>= 4;
+    if(value) {
+        *p-- = bits03_to_hex[value & 0xF];
+        value >>= 4;
+
+        while(value) {
+            *p-- = bits03_to_hex[value & 0xF];
+            value >>= 4;
+
+            if(value) {
+                *p-- = bits03_to_hex[value & 0xF];
+                value >>= 4;
+            }
+        }
+    }
+    *p-- = 'x';
+    *p   = '0';
+
+    buffer_fast_strcat(wb, (char *)p, e - p);
+}
+
 void buffer_fast_strcat(BUFFER *wb, const char *txt, size_t len) {
     if(unlikely(!txt || !*txt)) return;
 
diff --git a/libnetdata/buffer/buffer.h b/libnetdata/buffer/buffer.h
index 42425b4cb..ce6f52899 100644
--- a/libnetdata/buffer/buffer.h
+++ b/libnetdata/buffer/buffer.h
@@ -49,35 +49,37 @@ typedef struct web_buffer {
 #define buffer_no_cacheable(wb) do { (wb)->options |= WB_CONTENT_NO_CACHEABLE; if((wb)->options & WB_CONTENT_CACHEABLE)    (wb)->options &= ~WB_CONTENT_CACHEABLE;  (wb)->expires = 0; } while(0)
 
 #define buffer_strlen(wb) ((wb)->len)
-extern const char *buffer_tostring(BUFFER *wb);
+const char *buffer_tostring(BUFFER *wb);
 
 #define buffer_flush(wb) wb->buffer[(wb)->len = 0] = '\0'
-extern void buffer_reset(BUFFER *wb);
+void buffer_reset(BUFFER *wb);
 
-extern void buffer_strcat(BUFFER *wb, const char *txt);
-extern void buffer_fast_strcat(BUFFER *wb, const char *txt, size_t len);
-extern void buffer_rrd_value(BUFFER *wb, NETDATA_DOUBLE value);
+void buffer_strcat(BUFFER *wb, const char *txt);
+void buffer_fast_strcat(BUFFER *wb, const char *txt, size_t len);
+void buffer_rrd_value(BUFFER *wb, NETDATA_DOUBLE value);
 
-extern void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds);
-extern void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds);
+void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds);
+void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds);
 
-extern BUFFER *buffer_create(size_t size);
-extern void buffer_free(BUFFER *b);
-extern void buffer_increase(BUFFER *b, size_t free_size_required);
+BUFFER *buffer_create(size_t size);
+void buffer_free(BUFFER *b);
+void buffer_increase(BUFFER *b, size_t free_size_required);
 
-extern void buffer_snprintf(BUFFER *wb, size_t len, const char *fmt, ...) PRINTFLIKE(3, 4);
-extern void buffer_vsprintf(BUFFER *wb, const char *fmt, va_list args);
-extern void buffer_sprintf(BUFFER *wb, const char *fmt, ...) PRINTFLIKE(2,3);
-extern void buffer_strcat_jsonescape(BUFFER *wb, const char *txt);
-extern void buffer_strcat_htmlescape(BUFFER *wb, const char *txt);
+void buffer_snprintf(BUFFER *wb, size_t len, const char *fmt, ...) PRINTFLIKE(3, 4);
+void buffer_vsprintf(BUFFER *wb, const char *fmt, va_list args);
+void buffer_sprintf(BUFFER *wb, const char *fmt, ...) PRINTFLIKE(2,3);
+void buffer_strcat_jsonescape(BUFFER *wb, const char *txt);
+void buffer_strcat_htmlescape(BUFFER *wb, const char *txt);
 
-extern void buffer_char_replace(BUFFER *wb, char from, char to);
+void buffer_char_replace(BUFFER *wb, char from, char to);
 
-extern char *print_number_lu_r(char *str, unsigned long uvalue);
-extern char *print_number_llu_r(char *str, unsigned long long uvalue);
-extern char *print_number_llu_r_smart(char *str, unsigned long long uvalue);
+char *print_number_lu_r(char *str, unsigned long uvalue);
+char *print_number_llu_r(char *str, unsigned long long uvalue);
+char *print_number_llu_r_smart(char *str, unsigned long long uvalue);
 
-extern void buffer_print_llu(BUFFER *wb, unsigned long long uvalue);
+void buffer_print_llu(BUFFER *wb, unsigned long long uvalue);
+void buffer_print_ll(BUFFER *wb, long long value);
+void buffer_print_llu_hex(BUFFER *wb, unsigned long long value);
 
 static inline void buffer_need_bytes(BUFFER *buffer, size_t needed_free_size) {
     if(unlikely(buffer->size - buffer->len < needed_free_size))
diff --git a/libnetdata/circular_buffer/circular_buffer.c b/libnetdata/circular_buffer/circular_buffer.c
index 998008db2..c791b420b 100644
--- a/libnetdata/circular_buffer/circular_buffer.c
+++ b/libnetdata/circular_buffer/circular_buffer.c
@@ -46,6 +46,11 @@ static int cbuffer_realloc_unsafe(struct circular_buffer *buf) {
     return 0;
 }
 
+size_t cbuffer_available_size_unsafe(struct circular_buffer *buf) {
+    size_t len = (buf->write >= buf->read) ? (buf->write - buf->read) : (buf->size - buf->read + buf->write);
+    return buf->max_size - len;
+}
+
 int cbuffer_add_unsafe(struct circular_buffer *buf, const char *d, size_t d_len) {
     size_t len = (buf->write >= buf->read) ? (buf->write - buf->read) : (buf->size - buf->read + buf->write);
     while (d_len + len >= buf->size) {
@@ -78,8 +83,14 @@ void cbuffer_remove_unsafe(struct circular_buffer *buf, size_t num) {
 size_t cbuffer_next_unsafe(struct circular_buffer *buf, char **start) {
     if (start != NULL)
       *start = buf->data + buf->read;
+
     if (buf->read <= buf->write) {
         return buf->write - buf->read;      // Includes empty case
     }
     return buf->size - buf->read;
 }
+
+void cbuffer_flush(struct circular_buffer*buf) {
+    buf->write = 0;
+    buf->read = 0;
+}
\ No newline at end of file
diff --git a/libnetdata/circular_buffer/circular_buffer.h b/libnetdata/circular_buffer/circular_buffer.h
index ba37e0ebf..8c42aa807 100644
--- a/libnetdata/circular_buffer/circular_buffer.h
+++ b/libnetdata/circular_buffer/circular_buffer.h
@@ -8,9 +8,12 @@ struct circular_buffer {
     char *data;
 };
 
-extern struct circular_buffer *cbuffer_new(size_t initial, size_t max);
-extern void cbuffer_free(struct circular_buffer *buf);
-extern int cbuffer_add_unsafe(struct circular_buffer *buf, const char *d, size_t d_len);
-extern void cbuffer_remove_unsafe(struct circular_buffer *buf, size_t num);
-extern size_t cbuffer_next_unsafe(struct circular_buffer *buf, char **start);
+struct circular_buffer *cbuffer_new(size_t initial, size_t max);
+void cbuffer_free(struct circular_buffer *buf);
+int cbuffer_add_unsafe(struct circular_buffer *buf, const char *d, size_t d_len);
+void cbuffer_remove_unsafe(struct circular_buffer *buf, size_t num);
+size_t cbuffer_next_unsafe(struct circular_buffer *buf, char **start);
+size_t cbuffer_available_size_unsafe(struct circular_buffer *buf);
+void cbuffer_flush(struct circular_buffer*buf);
+
 #endif
diff --git a/libnetdata/clocks/clocks.c b/libnetdata/clocks/clocks.c
index e4dca6c8b..cabc0000e 100644
--- a/libnetdata/clocks/clocks.c
+++ b/libnetdata/clocks/clocks.c
@@ -11,14 +11,14 @@ usec_t clock_monotonic_resolution = 1000;
 usec_t clock_realtime_resolution = 1000;
 
 #ifndef HAVE_CLOCK_GETTIME
-inline int clock_gettime(clockid_t clk_id, struct timespec *ts) {
+inline int clock_gettime(clockid_t clk_id __maybe_unused, struct timespec *ts) {
     struct timeval tv;
     if(unlikely(gettimeofday(&tv, NULL) == -1)) {
         error("gettimeofday() failed.");
         return -1;
     }
     ts->tv_sec = tv.tv_sec;
-    ts->tv_nsec = (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC;
+    ts->tv_nsec = (long)((tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC);
     return 0;
 }
 #endif
@@ -197,28 +197,28 @@ void sleep_to_absolute_time(usec_t usec) {
                 if (!einval_printed) {
                     einval_printed++;
                     error(
-                        "Invalid time given to clock_nanosleep(): clockid = %d, tv_sec = %ld, tv_nsec = %ld",
+                        "Invalid time given to clock_nanosleep(): clockid = %d, tv_sec = %lld, tv_nsec = %ld",
                         clock,
-                        req.tv_sec,
+                        (long long)req.tv_sec,
                         req.tv_nsec);
                 }
             } else if (ret == ENOTSUP) {
                 if (!enotsup_printed) {
                     enotsup_printed++;
                     error(
-                        "Invalid clock id given to clock_nanosleep(): clockid = %d, tv_sec = %ld, tv_nsec = %ld",
+                        "Invalid clock id given to clock_nanosleep(): clockid = %d, tv_sec = %lld, tv_nsec = %ld",
                         clock,
-                        req.tv_sec,
+                        (long long)req.tv_sec,
                         req.tv_nsec);
                 }
             } else {
                 if (!eunknown_printed) {
                     eunknown_printed++;
                     error(
-                        "Unknown return value %d from clock_nanosleep(): clockid = %d, tv_sec = %ld, tv_nsec = %ld",
+                        "Unknown return value %d from clock_nanosleep(): clockid = %d, tv_sec = %lld, tv_nsec = %ld",
                         ret,
                         clock,
-                        req.tv_sec,
+                        (long long)req.tv_sec,
                         req.tv_nsec);
                 }
             }
@@ -341,20 +341,21 @@ usec_t heartbeat_next(heartbeat_t *hb, usec_t tick) {
 void sleep_usec(usec_t usec) {
     // we expect microseconds (1.000.000 per second)
     // but timespec is nanoseconds (1.000.000.000 per second)
-    struct timespec rem, req = {
+    struct timespec rem = { 0, 0 }, req = {
             .tv_sec = (time_t) (usec / USEC_PER_SEC),
             .tv_nsec = (suseconds_t) ((usec % USEC_PER_SEC) * NSEC_PER_USEC)
     };
 
 #ifdef __linux__
-    while ((errno = clock_nanosleep(CLOCK_REALTIME, 0, &req, &rem)) != 0) {
+    while (clock_nanosleep(CLOCK_REALTIME, 0, &req, &rem) != 0) {
 #else
-    while ((errno = nanosleep(&req, &rem)) != 0) {
+    while (nanosleep(&req, &rem) != 0) {
 #endif
-        if (likely(errno == EINTR)) {
-            req.tv_sec = rem.tv_sec;
-            req.tv_nsec = rem.tv_nsec;
-        } else {
+        if (likely(errno == EINTR && (rem.tv_sec || rem.tv_nsec))) {
+            req = rem;
+            rem = (struct timespec){ 0, 0 };
+        }
+        else {
 #ifdef __linux__
             error("Cannot clock_nanosleep(CLOCK_REALTIME) for %llu microseconds.", usec);
 #else
diff --git a/libnetdata/clocks/clocks.h b/libnetdata/clocks/clocks.h
index 53c036ece..7738a2c8e 100644
--- a/libnetdata/clocks/clocks.h
+++ b/libnetdata/clocks/clocks.h
@@ -82,7 +82,7 @@ typedef struct heartbeat {
  * make systems without clock_gettime() support sensitive
  * to time jumps or hibernation/suspend side effects.
  */
-extern int clock_gettime(clockid_t clk_id, struct timespec *ts);
+int clock_gettime(clockid_t clk_id, struct timespec *ts);
 #endif
 
 /*
@@ -111,50 +111,50 @@ extern int clock_gettime(clockid_t clk_id, struct timespec *ts);
  * All now_*_usec() functions return the time in microseconds from the appropriate clock, or 0 on error.
  *
  */
-extern int now_realtime_timeval(struct timeval *tv);
-extern time_t now_realtime_sec(void);
-extern usec_t now_realtime_usec(void);
+int now_realtime_timeval(struct timeval *tv);
+time_t now_realtime_sec(void);
+usec_t now_realtime_usec(void);
 
-extern int now_monotonic_timeval(struct timeval *tv);
-extern time_t now_monotonic_sec(void);
-extern usec_t now_monotonic_usec(void);
-extern int now_monotonic_high_precision_timeval(struct timeval *tv);
-extern time_t now_monotonic_high_precision_sec(void);
-extern usec_t now_monotonic_high_precision_usec(void);
+int now_monotonic_timeval(struct timeval *tv);
+time_t now_monotonic_sec(void);
+usec_t now_monotonic_usec(void);
+int now_monotonic_high_precision_timeval(struct timeval *tv);
+time_t now_monotonic_high_precision_sec(void);
+usec_t now_monotonic_high_precision_usec(void);
 
-extern int now_boottime_timeval(struct timeval *tv);
-extern time_t now_boottime_sec(void);
-extern usec_t now_boottime_usec(void);
+int now_boottime_timeval(struct timeval *tv);
+time_t now_boottime_sec(void);
+usec_t now_boottime_usec(void);
 
-extern usec_t timeval_usec(struct timeval *tv);
-extern msec_t timeval_msec(struct timeval *tv);
+usec_t timeval_usec(struct timeval *tv);
+msec_t timeval_msec(struct timeval *tv);
 
-extern usec_t dt_usec(struct timeval *now, struct timeval *old);
-extern susec_t dt_usec_signed(struct timeval *now, struct timeval *old);
+usec_t dt_usec(struct timeval *now, struct timeval *old);
+susec_t dt_usec_signed(struct timeval *now, struct timeval *old);
 
-extern void heartbeat_init(heartbeat_t *hb);
+void heartbeat_init(heartbeat_t *hb);
 
 /* Sleeps until next multiple of tick using monotonic clock.
  * Returns elapsed time in microseconds since previous heartbeat
  */
-extern usec_t heartbeat_next(heartbeat_t *hb, usec_t tick);
+usec_t heartbeat_next(heartbeat_t *hb, usec_t tick);
 
-extern void heartbeat_statistics(usec_t *min_ptr, usec_t *max_ptr, usec_t *average_ptr, size_t *count_ptr);
+void heartbeat_statistics(usec_t *min_ptr, usec_t *max_ptr, usec_t *average_ptr, size_t *count_ptr);
 
-extern void sleep_usec(usec_t usec);
+void sleep_usec(usec_t usec);
 
-extern void clocks_init(void);
+void clocks_init(void);
 
 // lower level functions - avoid using directly
-extern time_t now_sec(clockid_t clk_id);
-extern usec_t now_usec(clockid_t clk_id);
-extern int now_timeval(clockid_t clk_id, struct timeval *tv);
+time_t now_sec(clockid_t clk_id);
+usec_t now_usec(clockid_t clk_id);
+int now_timeval(clockid_t clk_id, struct timeval *tv);
 
-extern collected_number uptime_msec(char *filename);
+collected_number uptime_msec(char *filename);
 
 extern usec_t clock_monotonic_resolution;
 extern usec_t clock_realtime_resolution;
 
-extern void sleep_to_absolute_time(usec_t usec);
+void sleep_to_absolute_time(usec_t usec);
 
 #endif /* NETDATA_CLOCKS_H */
diff --git a/libnetdata/config/appconfig.c b/libnetdata/config/appconfig.c
index 1288366da..938c7dde2 100644
--- a/libnetdata/config/appconfig.c
+++ b/libnetdata/config/appconfig.c
@@ -32,8 +32,8 @@ _CONNECTOR_INSTANCE *add_connector_instance(struct section *connector, struct se
     local_ci = callocz(1, sizeof(struct _connector_instance));
     local_ci->instance = instance;
     local_ci->connector = connector;
-    strncpy(local_ci->instance_name, instance->name, CONFIG_MAX_NAME);
-    strncpy(local_ci->connector_name, connector->name, CONFIG_MAX_NAME);
+    strncpyz(local_ci->instance_name, instance->name, CONFIG_MAX_NAME);
+    strncpyz(local_ci->connector_name, connector->name, CONFIG_MAX_NAME);
     local_ci->next = global_connector_instance;
     global_connector_instance = local_ci;
 
@@ -473,7 +473,7 @@ NETDATA_DOUBLE appconfig_get_float(struct config *root, const char *section, con
     return str2ndd(s, NULL);
 }
 
-static inline int appconfig_test_boolean_value(char *s) {
+inline int appconfig_test_boolean_value(char *s) {
     if(!strcasecmp(s, "yes") || !strcasecmp(s, "true") || !strcasecmp(s, "on")
        || !strcasecmp(s, "auto") || !strcasecmp(s, "on demand"))
         return 1;
@@ -686,14 +686,14 @@ int appconfig_load(struct config *root, char *filename, int overwrite_used, cons
                     int rc;
                     rc = is_valid_connector(s, 0);
                     if (likely(rc)) {
-                        strncpy(working_connector, s, CONFIG_MAX_NAME);
+                        strncpyz(working_connector, s, CONFIG_MAX_NAME);
                         s = s + rc + 1;
                         if (unlikely(!(*s))) {
                             _connectors++;
                             sprintf(buffer, "instance_%d", _connectors);
                             s = buffer;
                         }
-                        strncpy(working_instance, s, CONFIG_MAX_NAME);
+                        strncpyz(working_instance, s, CONFIG_MAX_NAME);
                         working_connector_section = NULL;
                         if (unlikely(appconfig_section_find(root, working_instance))) {
                             error("Instance (%s) already exists", working_instance);
diff --git a/libnetdata/config/appconfig.h b/libnetdata/config/appconfig.h
index d72a3140e..2828e107a 100644
--- a/libnetdata/config/appconfig.h
+++ b/libnetdata/config/appconfig.h
@@ -163,41 +163,43 @@ struct config {
 #define CONFIG_BOOLEAN_AUTO 2       // enabled if it has useful info when enabled
 #endif
 
-extern int appconfig_load(struct config *root, char *filename, int overwrite_used, const char *section_name);
-extern void config_section_wrlock(struct section *co);
-extern void config_section_unlock(struct section *co);
+int appconfig_load(struct config *root, char *filename, int overwrite_used, const char *section_name);
+void config_section_wrlock(struct section *co);
+void config_section_unlock(struct section *co);
 
-extern char *appconfig_get_by_section(struct section *co, const char *name, const char *default_value);
-extern char *appconfig_get(struct config *root, const char *section, const char *name, const char *default_value);
-extern long long appconfig_get_number(struct config *root, const char *section, const char *name, long long value);
-extern NETDATA_DOUBLE appconfig_get_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value);
-extern int appconfig_get_boolean_by_section(struct section *co, const char *name, int value);
-extern int appconfig_get_boolean(struct config *root, const char *section, const char *name, int value);
-extern int appconfig_get_boolean_ondemand(struct config *root, const char *section, const char *name, int value);
-extern int appconfig_get_duration(struct config *root, const char *section, const char *name, const char *value);
+char *appconfig_get_by_section(struct section *co, const char *name, const char *default_value);
+char *appconfig_get(struct config *root, const char *section, const char *name, const char *default_value);
+long long appconfig_get_number(struct config *root, const char *section, const char *name, long long value);
+NETDATA_DOUBLE appconfig_get_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value);
+int appconfig_get_boolean_by_section(struct section *co, const char *name, int value);
+int appconfig_get_boolean(struct config *root, const char *section, const char *name, int value);
+int appconfig_get_boolean_ondemand(struct config *root, const char *section, const char *name, int value);
+int appconfig_get_duration(struct config *root, const char *section, const char *name, const char *value);
 
-extern const char *appconfig_set(struct config *root, const char *section, const char *name, const char *value);
-extern const char *appconfig_set_default(struct config *root, const char *section, const char *name, const char *value);
-extern long long appconfig_set_number(struct config *root, const char *section, const char *name, long long value);
-extern NETDATA_DOUBLE appconfig_set_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value);
-extern int appconfig_set_boolean(struct config *root, const char *section, const char *name, int value);
+const char *appconfig_set(struct config *root, const char *section, const char *name, const char *value);
+const char *appconfig_set_default(struct config *root, const char *section, const char *name, const char *value);
+long long appconfig_set_number(struct config *root, const char *section, const char *name, long long value);
+NETDATA_DOUBLE appconfig_set_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value);
+int appconfig_set_boolean(struct config *root, const char *section, const char *name, int value);
 
-extern int appconfig_exists(struct config *root, const char *section, const char *name);
-extern int appconfig_move(struct config *root, const char *section_old, const char *name_old, const char *section_new, const char *name_new);
+int appconfig_exists(struct config *root, const char *section, const char *name);
+int appconfig_move(struct config *root, const char *section_old, const char *name_old, const char *section_new, const char *name_new);
 
-extern void appconfig_generate(struct config *root, BUFFER *wb, int only_changed);
+void appconfig_generate(struct config *root, BUFFER *wb, int only_changed);
 
-extern int appconfig_section_compare(void *a, void *b);
+int appconfig_section_compare(void *a, void *b);
 
-extern void appconfig_section_destroy_non_loaded(struct config *root, const char *section);
-extern void appconfig_section_option_destroy_non_loaded(struct config *root, const char *section, const char *name);
+void appconfig_section_destroy_non_loaded(struct config *root, const char *section);
+void appconfig_section_option_destroy_non_loaded(struct config *root, const char *section, const char *name);
 
-extern int config_parse_duration(const char* string, int* result);
+int config_parse_duration(const char* string, int* result);
 
-extern struct section *appconfig_get_section(struct config *root, const char *name);
+struct section *appconfig_get_section(struct config *root, const char *name);
 
-extern void appconfig_wrlock(struct config *root);
-extern void appconfig_unlock(struct config *root);
+void appconfig_wrlock(struct config *root);
+void appconfig_unlock(struct config *root);
+
+int appconfig_test_boolean_value(char *s);
 
 struct connector_instance {
     char instance_name[CONFIG_MAX_NAME + 1];
@@ -212,6 +214,6 @@ typedef struct _connector_instance {
     struct _connector_instance *next; // Next instance
 } _CONNECTOR_INSTANCE;
 
-extern _CONNECTOR_INSTANCE *add_connector_instance(struct section *connector, struct section *instance);
+_CONNECTOR_INSTANCE *add_connector_instance(struct section *connector, struct section *instance);
 
 #endif /* NETDATA_CONFIG_H */
diff --git a/libnetdata/dictionary/README.md b/libnetdata/dictionary/README.md
index 879c1bcc1..6d7e55392 100644
--- a/libnetdata/dictionary/README.md
+++ b/libnetdata/dictionary/README.md
@@ -18,52 +18,61 @@ Dictionaries provide an interface to:
 - **Delete** an item from the dictionary (provided its `name`)
 - **Traverse** the list of items in the dictionary
 
-Dictionaries are **ordered**, meaning that the order they have been added is preserved while traversing them. The caller may reverse this order by passing the flag `DICTIONARY_FLAG_ADD_IN_FRONT` when creating the dictionary.
+Dictionaries are **ordered**, meaning that the order they have been added, is preserved while traversing them. The caller may reverse this order by passing the flag `DICT_OPTION_ADD_IN_FRONT` when creating the dictionary.
 
-Dictionaries guarantee **uniqueness** of all items added to them, meaning that only one item with a given name can exist in the dictionary at any given time.
+Dictionaries guarantee **uniqueness** of all items added to them, meaning that only one item with a given `name` can exist in the dictionary at any given time.
 
-Dictionaries are extremely fast in all operations. They are indexing the keys with `JudyHS` (or `AVL` when `libJudy` is not available) and they utilize a double-linked-list for the traversal operations. Deletion is the most expensive operation, usually somewhat slower than insertion.
+Dictionaries are extremely fast in all operations. They are indexing the keys with `JudyHS` and they utilize a double-linked-list for the traversal operations. Deletion is the most expensive operation, usually somewhat slower than insertion.
 
 ## Memory management
 
 Dictionaries come with 2 memory management options:
 
-- **Clone** (copy) the name and/or the value to memory allocated by the dictionary.
-- **Link** the name and/or the value, without allocating any memory about them.
+- **Clone** (copy) the `name` and/or the `value` to memory allocated by the dictionary.
+- **Link** the `name` and/or the `value`, without allocating any memory about them.
 
-In **clone** mode, the dictionary guarantees that all operations on the dictionary items will automatically take care of the memory used by the name and/or the value. In case the value is an object that needs to have user allocated memory, the following callback functions can be registered:
+In **clone** mode, the dictionary guarantees that all operations on the dictionary items, will automatically take care of the memory used by the `name` and/or the `value`. In case the `value` is an object that needs to have user allocated memory, the following callback functions can be registered:
 
-   1.`dictionary_register_insert_callback()` that will be called just after the insertion of an item to the dictionary, or after the replacement of the value of a dictionary item (but while the dictionary is write-locked - if locking is enabled).
-   2. `dictionary_register_delete_callback()` that will be called just prior to the deletion of an item from the dictionary, or prior to the replacement of the value of a dictionary item (but while the dictionary is write-locked - if locking is enabled).
-   3. `dictionary_register_conflict_callback()` that will be called when `DICTIONARY_FLAG_DONT_OVERWRITE_VALUE` is set and another value is attempted to be inserted for the same key. 
+1. `dictionary_register_insert_callback()` that can be called just after the insertion of an item to the dictionary, or after the replacement of the value of a dictionary item.
+2. `dictionary_register_delete_callback()` that will be called just prior to the deletion of an item from the dictionary, or prior to the replacement of the value of a dictionary item.
+3. `dictionary_register_conflict_callback()` that will be called when `DICT_OPTION_DONT_OVERWRITE_VALUE` is set, and another `value` is attempted to be inserted for the same key.
+4. `dictionary_register_react_callback()` that will be called after the the `insert` and the `conflict` callbacks. The `conflict` callback is called while the dictionary hash table is available for other threads.
 
-In **link** mode, the name and/or the value are just linked to the dictionary item, and it is the user's responsibility to free the memory they use after an item is deleted from the dictionary or when the dictionary is destroyed.
+In **link** mode, the `name` and/or the `value` are just linked to the dictionary item, and it is the user's responsibility to free the memory they use after an item is deleted from the dictionary or when the dictionary is destroyed.
 
 By default, **clone** mode is used for both the name and the value.
 
-To use **link** mode for names, add `DICTIONARY_FLAG_NAME_LINK_DONT_CLONE` to the flags when creating the dictionary.
+To use **link** mode for names, add `DICT_OPTION_NAME_LINK_DONT_CLONE` to the flags when creating the dictionary.
 
-To use **link** mode for values, add `DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE` to the flags when creating the dictionary.
+To use **link** mode for values, add `DICT_OPTION_VALUE_LINK_DONT_CLONE` to the flags when creating the dictionary.
 
 ## Locks
 
 The dictionary allows both **single-threaded** operation (no locks - faster) and **multi-threaded** operation utilizing a read-write lock.
 
-The default is **multi-threaded**. To enable **single-threaded** add `DICTIONARY_FLAG_SINGLE_THREADED` to the flags when creating the dictionary.
+The default is **multi-threaded**. To enable **single-threaded** add `DICT_OPTION_SINGLE_THREADED` to the flags when creating the dictionary.
+
+When in **multi-threaded** mode, the dictionaries have 2 independent R/W locks. One for the linked list and one for the hash table (index). An insertion and a deletion will acquire both independently (one after another) for as long as they are needed, but a traversal may hold the the linked list for longer durations. The hash table (index) lock may be acquired while the linked list is acquired, but not the other way around (and the way the code is structured, it is not technically possible to hold and index lock and then lock the linked list one).
+
+These locks are R/W locks. They allow multiple readers, but only one writer.
+
+Unlike POSIX standards, the linked-list lock, allows one writer to lock it multiple times. This has been implemented in such a way, so that a traversal to the items of the dictionary in write-lock mode, allows the writing thread to call `dictionary_set()` or `dictionary_del()`, which alter the dictionary index and the linked list. Especially for the deletion of the currently working item, the dictionary support delayed removal, so it will remove it from the index immediately and mark it as deleted, so that it can be added to the dictionary again with a different value and the traversal will still proceed from the point it was. 
 
 ## Hash table operations
 
 The dictionary supports the following operations supported by the hash table:
 
 - `dictionary_set()` to add an item to the dictionary, or change its value.
-- `dictionary_get()` to get an item from the dictionary.
+- `dictionary_get()` and `dictionary_get_and_acquire_item()` to get an item from the dictionary.
 - `dictionary_del()` to delete an item from the dictionary.
 
+For all the calls, there are also `*_advanced()` versions of them, that support more parameters. Check the header file for more information about them.
+
 ## Creation and destruction
 
 Use `dictionary_create()` to create a dictionary.
 
-Use `dictionary_destroy()` to destroy a dictionary. When destroyed, a dictionary frees all the memory it has allocated on its own. This can be complemented by the registration of a deletion callback function that can be called upon deletion of each item in the dictionary, which may free additional resources. 
+Use `dictionary_destroy()` to destroy a dictionary. When destroyed, a dictionary frees all the memory it has allocated on its own. This can be complemented by the registration of a deletion callback function that can be called upon deletion of each item in the dictionary, which may free additional resources linked to it. 
 
 ### dictionary_set()
 
@@ -72,9 +81,7 @@ This call is used to:
 - **add** an item to the dictionary.
 - **reset** the value of an existing item in the dictionary.
 
-If **resetting** is not desired, add `DICTIONARY_FLAG_DONT_OVERWRITE_VALUE` to the flags when creating the dictionary. In this case, `dictionary_set()` will return the value of the original item found in the dictionary instead of resetting it and the value passed to the call will be ignored. Optionally a conflict callback function can be registered, to manipulate (probably merge or extend) the original value, based on the new value attempted to be added to the dictionary.
-
-For **multi-threaded** operation, the `dictionary_set()` calls get an exclusive write lock on the dictionary.
+If **resetting** is not desired, add `DICT_OPTION_DONT_OVERWRITE_VALUE` to the flags when creating the dictionary. In this case, `dictionary_set()` will return the value of the original item found in the dictionary instead of resetting it and the value passed to the call will be ignored. Optionally a conflict callback function can be registered, to manipulate (probably merge or extend) the original value, based on the new value attempted to be added to the dictionary.
 
 The format is:
 
@@ -87,17 +94,15 @@ Where:
 * `dict` is a pointer to the dictionary previously created.
 * `name` is a pointer to a string to be used as the key of this item. The name must not be `NULL` and must not be an empty string `""`.
 * `value` is a pointer to the value associated with this item. In **clone** mode, if `value` is `NULL`, a new memory allocation will be made of `value_len` size and will be initialized to zero.
-* `value_len` is the size of the `value` data. If `value_len` is zero, no allocation will be done and the dictionary item will permanently have the `NULL` value.
-
-> **IMPORTANT**<br/>There is also an **unsafe** version (without locks) of this call. This is to be used when traversing the dictionary in write mode. It should never be called without an active lock on the dictionary, which can only be acquired while traversing.
+* `value_len` is the size of the `value` data in bytes. If `value_len` is zero, no allocation will be done and the dictionary item will permanently have the `NULL` value.
 
 ### dictionary_get()
 
-This call is used to get the value of an item, given its name. It utilizes the `JudyHS` hash table for making the lookup.
+This call is used to get the `value` of an item, given its `name`. It utilizes the hash table (index) for making the lookup.
 
-For **multi-threaded** operation, the `dictionary_get()` call gets a shared read lock on the dictionary.
+For **multi-threaded** operation, the `dictionary_get()` call gets a shared read lock on the index lock (multiple readers are allowed). The linked-list lock is not used.
 
-In clone mode, the value returned is not guaranteed to be valid, as any other thread may delete the item from the dictionary at any time. To ensure the value will be available, use `dictionary_get_and_acquire_item()`, which uses a reference counter to defer deletes until the item is released.
+In clone mode, the value returned is not guaranteed to be valid, as any other thread may delete the item from the dictionary at any time. To ensure the value will be available, use `dictionary_get_and_acquire_item()`, which uses a reference counter to defer deletes until the item is released with `dictionary_acquired_item_release()`.
 
 The format is:
 
@@ -110,16 +115,12 @@ Where:
 * `dict` is a pointer to the dictionary previously created.
 * `name` is a pointer to a string to be used as the key of this item. The name must not be `NULL` and must not be an empty string `""`.
 
-> **IMPORTANT**<br/>There is also an **unsafe** version (without locks) of this call. This is to be used when traversing the dictionary. It should never be called without an active lock on the dictionary, which can only be acquired while traversing.
-
 ### dictionary_del()
 
 This call is used to delete an item from the dictionary, given its name.
 
 If there is a deletion callback registered to the dictionary (`dictionary_register_delete_callback()`), it is called prior to the actual deletion of the item. 
 
-For **multi-threaded** operation, the `dictionary_del()` calls get an exclusive write lock on the dictionary.
-
 The format is:
 
 ```c
@@ -131,11 +132,9 @@ Where:
 * `dict` is a pointer to the dictionary previously created.
 * `name` is a pointer to a string to be used as the key of this item. The name must not be `NULL` and must not be an empty string `""`.
 
-> **IMPORTANT**<br/>There is also an **unsafe** version (without locks) of this call. This is to be used when traversing the dictionary, to delete the current item. It should never be called without an active lock on the dictionary, which can only be acquired while traversing.
-
 ### dictionary_get_and_acquire_item()
 
-This call can be used the search and get a dictionary item, while ensuring that it will be available for use, until `dictionary_acquired_item_release()` is called.
+This call can be used to search and acquire a dictionary item, while ensuring that it will be available for use, until `dictionary_acquired_item_release()` is called.
 
 This call **does not return the value** of the dictionary item. It returns an internal pointer to a structure that maintains the reference counter used to protect the actual value. To get the value of the item (the same value as returned by `dictionary_get()`), the function `dictionary_acquired_item_value()` has to be called.
 
@@ -143,13 +142,13 @@ Example:
 
 ```c
 // create the dictionary
-DICTIONARY *dict = dictionary_create(DICTIONARY_FLAGS_NONE);
+DICTIONARY *dict = dictionary_create(DICT_OPTION_NONE);
 
 // add an item to it
 dictionary_set(dict, "name", "value", 6);
 
 // find the item we added and acquire it
-void *item = dictionary_get_and_acquire_item(dict, "name");
+const DICTIONARY_ITEM *item = dictionary_get_and_acquire_item(dict, "name");
 
 // extract its value
 char *value = (char *)dictionary_acquired_item_value(dict, item);
@@ -164,7 +163,7 @@ dictionary_acquired_item_release(dict, item);
 dictionary_destroy(dict);
 ```
 
-When items are acquired, a reference counter is maintained to keep track of how many users exist for it. If an item with a non-zero number of users is deleted, it is removed from the index, it can be added again to the index (without conflict), and although it exists in the linked-list, it is not offered during traversal. Garbage collection to actually delete the item happens every time a write-locked dictionary is unlocked (just before the unlock) and items are deleted only if no users are using them.
+When items are acquired, a reference counter is maintained to keep track of how many users exist for it. If an item with a non-zero number of users is deleted, it is removed from the index, it can be added again to the index (without conflict), and although it exists in the linked-list, it is not offered during traversal. Garbage collection to actually delete the item happens every time another item is added or removed from the linked-list and items are deleted only if no users are using them.
 
 If any item is still acquired when the dictionary is destroyed, the destruction of the dictionary is also deferred until all the acquired items are released. When the dictionary is destroyed like that, all operations on the dictionary fail (traversals do not traverse, insertions do not insert, deletions do not delete, searches do not find any items, etc). Once the last item in the dictionary is released, the dictionary is automatically destroyed too.
 
@@ -176,20 +175,16 @@ Dictionaries offer 3 ways to traverse the entire dictionary:
 - **sorted walkthrough**, which first sorts the dictionary and then call a callback function for every item.
 - **foreach**, a way to traverse the dictionary with a for-next loop.
 
-All these methods are available in **read** or **write** mode. In **read** mode only lookups are allowed to the dictionary. In **write** lookups but also insertions and deletions are allowed.
-
-While traversing the dictionary with any of these methods, all calls to the dictionary have to use the `_unsafe` versions of the function calls, otherwise deadlocks may arise.
-
-> **IMPORTANT**<br/>The dictionary itself does not check to ensure that a user is actually using the right lock mode (read or write) while traversing the dictionary for each of the unsafe calls.
+All these methods are available in **read**, **write**, or **reentrant** mode. In **read** mode only lookups are allowed to the dictionary. In **write** lookups but also insertions and deletions are allowed, and in **reentrant** mode the dictionary is unlocked outside dictionary code.
 
 ### walkthrough (callback)
 
 There are 4 calls:
 
-- `dictionary_walkthrough_read()` and `dictionary_sorted_walkthrough_read()` that acquire a shared read lock, and they call a callback function for every item of the dictionary. The callback function may use the unsafe versions of the `dictionary_get()` calls to lookup other items in the dictionary, but it should not attempt to add or remove items to/from the dictionary.
-- `dictionary_walkthrough_write()` and `dictionary_sorted_walkthrough_write()` that acquire an exclusive write lock, and they call a callback function for every item of the dictionary. This is to be used when items need to be added to or removed from the dictionary. The `write` versions can be used to delete any or all the items from the dictionary, including the currently working one. For the `sorted` version, all items in the dictionary maintain a reference counter, so all deletions are deferred until the sorted walkthrough finishes.** 
+- `dictionary_walkthrough_read()` and `dictionary_sorted_walkthrough_read()` acquire a shared read lock on the linked-list, and they call a callback function for every item of the dictionary.
+- `dictionary_walkthrough_write()` and `dictionary_sorted_walkthrough_write()` acquire a write lock on the linked-list, and they call a callback function for every item of the dictionary. This is to be used when items need to be added to or removed from the dictionary. The `write` versions can be used to delete any or all the items from the dictionary, including the currently working one. For the `sorted` version, all items in the dictionary maintain a reference counter, so all deletions are deferred until the sorted walkthrough finishes. 
 
-The non sorted versions traverse the items in the same order they have been added to the dictionary (or the reverse order if the flag `DICTIONARY_FLAG_ADD_IN_FRONT` is set during dictionary creation). The sorted versions sort alphabetically the items based on their name, and then they traverse them in the sorted order.
+The non sorted versions traverse the items in the same order they have been added to the dictionary (or the reverse order if the flag `DICT_OPTION_ADD_IN_FRONT` is set during dictionary creation). The sorted versions sort alphabetically the items based on their name, and then they traverse them in the sorted order.
 
 The callback function returns an `int`. If this value is negative, traversal of the dictionary is stopped immediately and the negative value is returned to the caller. If the returned value of all callback calls is zero or positive, the walkthrough functions return the sum of the return values of all callbacks. So, if you are just interested to know how many items fall into some condition, write a callback function that returns 1 when the item satisfies that condition and 0 when it does not and the walkthrough function will return how many tested positive.
 
@@ -198,48 +193,39 @@ The callback function returns an `int`. If this value is negative, traversal of
 The following is a snippet of such a loop:
 
 ```c
-MY_ITEM *item;
-dfe_start_read(dict, item) {
-   printf("hey, I got an item named '%s' with value ptr %08X", item_name, item);
+MY_STRUCTURE *x;
+dfe_start_read(dict, x) {
+   printf("hey, I got an item named '%s' with value ptr %08X", x_dfe.name, x);
 }
-dfe_done(item);
+dfe_done(x);
 ```
 
-The `item` parameter gives the name of the pointer to be used while iterating the items. Any name is accepted.
+The `x` parameter gives the name of the pointer to be used while iterating the items. Any name is accepted. `x` points to the `value` of the item in the dictionary.
 
-The `item_name` is a variable that is automatically created, by concatenating whatever is given as `item` and `_name`. So, if you call `dfe_start_read(dict, myvar)`, the name will be `myvar_name`.
+The `x_dfe.name` is a variable that is automatically created, by concatenating whatever is given as `x` and `_dfe`. It is an object and it has a few members, including `x_dfe.counter` that counts the iterations made so far, `x_dfe.item` that provides the acquired item from the dictionary and which can be used to pass it over for further processing, etc. Check the header file for more info. So, if you call `dfe_start_read(dict, myvar)`, the name will be `myvar_dfe`.
 
 Both `dfe_start_read(dict, item)` and `dfe_done(item)` are together inside a `do { ... } while(0)` loop, so that the following will work:
 
 ```c
 MY_ITEM *item;
 
-if(x = 1)
+if(a = 1)
     // do {
-    dfe_start_read(dict, item)
-        printf("hey, I got an item named '%s' with value ptr %08X", item_name, item);
-    dfe_done(item);
+    dfe_start_read(dict, x)
+        printf("hey, I got an item named '%s' with value ptr %08X", x_dfe.name, x);
+    dfe_done(x);
     // } while(0);
 else
     something else;
 ```
 
-In the above, the `if(x == 1)` condition will work as expected. It will do the foreach loop when x is 1, otherwise it will run `something else`.
+In the above, the `if(a == 1)` condition will work as expected. It will do the foreach loop when a is 1, otherwise it will run `something else`.
 
 There are 2 versions of `dfe_start`:
 
-- `dfe_start_read()` that acquires a shared read lock to the dictionary.
-- `dfe_start_write()` that acquires an exclusive write lock to the dictionary.
+- `dfe_start_read()` that acquires a shared read linked-list lock to the dictionary.
+- `dfe_start_write()` that acquires an exclusive write linked-list lock to the dictionary.
 
-While in the loop, depending on the read or write versions of `dfe_start`, the caller may lookup or manipulate the dictionary using the unsafe functions. The rules are the same with the unsorted walkthrough callback functions.
+While in the loop, depending on the read or write versions of `dfe_start`, the caller may lookup or manipulate the dictionary. The rules are the same with the unsorted walkthrough callback functions.
 
 PS: DFE is Dictionary For Each.
-
-## special multi-threaded lockless case
-
-Since the dictionary uses a hash table and a double linked list, if the contract between 2 threads is for one to use the hash table functions only (`set`, `get` - but no `del`) and the other to use the traversal ones only, the dictionary allows concurrent use without locks.
-
-This is currently used in statsd:
-
-- the data collection thread uses only `get` and `set`. It never uses `del`. New items are added at the front of the linked list (`DICTIONARY_FLAG_ADD_IN_FRONT`).
-- the flushing thread is only traversing the dictionary up to the point it last traversed it (it uses a flag for that to know where it stopped last time). It never uses `get`, `set` or `del`.
diff --git a/libnetdata/dictionary/dictionary.c b/libnetdata/dictionary/dictionary.c
index c1325ecb5..f03da25ab 100644
--- a/libnetdata/dictionary/dictionary.c
+++ b/libnetdata/dictionary/dictionary.c
@@ -1,64 +1,137 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-// NOT TO BE USED BY USERS
-#define DICTIONARY_FLAG_EXCLUSIVE_ACCESS    (1 << 29) // there is only one thread accessing the dictionary
-#define DICTIONARY_FLAG_DESTROYED           (1 << 30) // this dictionary has been destroyed
-#define DICTIONARY_FLAG_DEFER_ALL_DELETIONS (1 << 31) // defer all deletions of items in the dictionary
-
-// our reserved flags that cannot be set by users
-#define DICTIONARY_FLAGS_RESERVED (DICTIONARY_FLAG_EXCLUSIVE_ACCESS|DICTIONARY_FLAG_DESTROYED|DICTIONARY_FLAG_DEFER_ALL_DELETIONS)
-
-typedef struct dictionary DICTIONARY;
 #define DICTIONARY_INTERNALS
 
 #include "../libnetdata.h"
+#include <Judy.h>
 
-#ifndef ENABLE_DBENGINE
-#define DICTIONARY_WITH_AVL
-#warning Compiling DICTIONARY with an AVL index
-#else
-#define DICTIONARY_WITH_JUDYHS
-#endif
+// runtime flags of the dictionary - must be checked with atomics
+typedef enum {
+    DICT_FLAG_NONE                  = 0,
+    DICT_FLAG_DESTROYED             = (1 << 0), // this dictionary has been destroyed
+} DICT_FLAGS;
 
-#ifdef DICTIONARY_WITH_JUDYHS
-#include <Judy.h>
-#endif
+#define dict_flag_check(dict, flag) (__atomic_load_n(&((dict)->flags), __ATOMIC_SEQ_CST) & (flag))
+#define dict_flag_set(dict, flag)   __atomic_or_fetch(&((dict)->flags), flag, __ATOMIC_SEQ_CST)
+#define dict_flag_clear(dict, flag) __atomic_and_fetch(&((dict)->flags), ~(flag), __ATOMIC_SEQ_CST)
+
+// flags macros
+#define is_dictionary_destroyed(dict) dict_flag_check(dict, DICT_FLAG_DESTROYED)
+
+// configuration options macros
+#define is_dictionary_single_threaded(dict) ((dict)->options & DICT_OPTION_SINGLE_THREADED)
+#define is_view_dictionary(dict) ((dict)->master)
+#define is_master_dictionary(dict) (!is_view_dictionary(dict))
+
+typedef enum item_options {
+    ITEM_OPTION_NONE            = 0,
+    ITEM_OPTION_ALLOCATED_NAME  = (1 << 0), // the name pointer is a STRING
+
+    // IMPORTANT: This is 1-bit - to add more change ITEM_OPTIONS_BITS
+} ITEM_OPTIONS;
+
+typedef enum item_flags {
+    ITEM_FLAG_NONE              = 0,
+    ITEM_FLAG_DELETED           = (1 << 0), // this item is marked deleted, so it is not available for traversal (deleted from the index too)
+    ITEM_FLAG_BEING_CREATED     = (1 << 1), // this item is currently being created - this flag is removed when construction finishes
+
+    // IMPORTANT: This is 8-bit
+} ITEM_FLAGS;
+
+#define item_flag_check(item, flag) (__atomic_load_n(&((item)->flags), __ATOMIC_SEQ_CST) & (flag))
+#define item_flag_set(item, flag)   __atomic_or_fetch(&((item)->flags), flag, __ATOMIC_SEQ_CST)
+#define item_flag_clear(item, flag) __atomic_and_fetch(&((item)->flags), ~(flag), __ATOMIC_SEQ_CST)
+
+#define item_shared_flag_check(item, flag) (__atomic_load_n(&((item)->shared->flags), __ATOMIC_SEQ_CST) & (flag))
+#define item_shared_flag_set(item, flag)   __atomic_or_fetch(&((item)->shared->flags), flag, __ATOMIC_SEQ_CST)
+#define item_shared_flag_clear(item, flag) __atomic_and_fetch(&((item)->shared->flags), ~(flag), __ATOMIC_SEQ_CST)
 
-typedef enum name_value_flags {
-    NAME_VALUE_FLAG_NONE                   = 0,
-    NAME_VALUE_FLAG_NAME_IS_ALLOCATED      = (1 << 0), // the name pointer is a STRING
-    NAME_VALUE_FLAG_DELETED                = (1 << 1), // this item is deleted, so it is not available for traversal
-    NAME_VALUE_FLAG_NEW_OR_UPDATED         = (1 << 2), // this item is new or just updated (used by the react callback)
+#define REFCOUNT_DELETING         (-100)
+
+#define ITEM_FLAGS_TYPE uint8_t
+#define KEY_LEN_TYPE    uint32_t
+#define VALUE_LEN_TYPE  uint32_t
+
+#define ITEM_OPTIONS_BITS 1
+#define KEY_LEN_BITS ((sizeof(KEY_LEN_TYPE) * 8) - (sizeof(ITEM_FLAGS_TYPE) * 8) - ITEM_OPTIONS_BITS)
+#define KEY_LEN_MAX ((1 << KEY_LEN_BITS) - 1)
+
+#define VALUE_LEN_BITS ((sizeof(VALUE_LEN_TYPE) * 8) - (sizeof(ITEM_FLAGS_TYPE) * 8))
+#define VALUE_LEN_MAX ((1 << VALUE_LEN_BITS) - 1)
 
-    // IMPORTANT: IF YOU ADD ANOTHER FLAG, YOU NEED TO ALLOCATE ANOTHER BIT TO FLAGS IN NAME_VALUE !!!
-} NAME_VALUE_FLAGS;
 
 /*
  * Every item in the dictionary has the following structure.
  */
 
-typedef struct name_value {
-#ifdef DICTIONARY_WITH_AVL
-    avl_t avl_node;
-#endif
+typedef int32_t REFCOUNT;
+
+typedef struct dictionary_item_shared {
+    void *value;                            // the value of the dictionary item
+
+    // the order of the following items is important!
+    // The total of their storage should be 64-bits
+
+    REFCOUNT links;                         // how many links this item has
+    VALUE_LEN_TYPE value_len:VALUE_LEN_BITS; // the size of the value
+    ITEM_FLAGS_TYPE flags;                  // shared flags
+} DICTIONARY_ITEM_SHARED;
 
+struct dictionary_item {
 #ifdef NETDATA_INTERNAL_CHECKS
     DICTIONARY *dict;
+    pid_t creator_pid;
+    pid_t deleter_pid;
+    pid_t ll_adder_pid;
+    pid_t ll_remover_pid;
 #endif
 
-    struct name_value *next;    // a double linked list to allow fast insertions and deletions
-    struct name_value *prev;
+    DICTIONARY_ITEM_SHARED *shared;
 
-    uint32_t refcount;          // the reference counter
-    uint32_t value_len:29;      // the size of the value (assumed binary)
-    uint8_t flags:3;            // the flags for this item
+    struct dictionary_item *next;           // a double linked list to allow fast insertions and deletions
+    struct dictionary_item *prev;
 
-    void *value;                // the value of the dictionary item
     union {
-        STRING *string_name;    // the name of the dictionary item
-        char *caller_name;      // the user supplied string pointer
+        STRING *string_name;                // the name of the dictionary item
+        char *caller_name;                  // the user supplied string pointer
+//        void *key_ptr;                      // binary key pointer
     };
-} NAME_VALUE;
+
+    // the order of the following items is important!
+    // The total of their storage should be 64-bits
+
+    REFCOUNT refcount;                      // the private reference counter
+
+    KEY_LEN_TYPE key_len:KEY_LEN_BITS;      // the size of key indexed (for strings, including the null terminator)
+                                            // this is (2^23 - 1) = 8.388.607 bytes max key length.
+
+    ITEM_OPTIONS options:ITEM_OPTIONS_BITS; // permanent configuration options
+                                            // (no atomic operations on this - they never change)
+
+    ITEM_FLAGS_TYPE flags;                  // runtime changing flags for this item (atomic operations on this)
+                                            // cannot be a bit field because of atomics.
+};
+
+struct dictionary_hooks {
+    REFCOUNT links;
+    usec_t last_master_deletion_us;
+
+    void (*ins_callback)(const DICTIONARY_ITEM *item, void *value, void *data);
+    void *ins_callback_data;
+
+    bool (*conflict_callback)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data);
+    void *conflict_callback_data;
+
+    void (*react_callback)(const DICTIONARY_ITEM *item, void *value, void *data);
+    void *react_callback_data;
+
+    void (*del_callback)(const DICTIONARY_ITEM *item, void *value, void *data);
+    void *del_callback_data;
+};
+
+struct dictionary_stats dictionary_stats_category_other = {
+    .name = "other",
+};
 
 struct dictionary {
 #ifdef NETDATA_INTERNAL_CHECKS
@@ -67,331 +140,685 @@ struct dictionary {
     size_t creation_line;
 #endif
 
-    DICTIONARY_FLAGS flags;             // the flags of the dictionary
+    usec_t last_gc_run_us;
+    DICT_OPTIONS options;               // the configuration flags of the dictionary (they never change - no atomics)
+    DICT_FLAGS flags;                   // run time flags for the dictionary (they change all the time - atomics needed)
+
+    struct {                            // support for multiple indexing engines
+        Pvoid_t JudyHSArray;            // the hash table
+        netdata_rwlock_t rwlock;        // protect the index
+    } index;
+
+    struct {
+        DICTIONARY_ITEM *list;          // the double linked list of all items in the dictionary
+        netdata_rwlock_t rwlock;        // protect the linked-list
+        pid_t writer_pid;               // the gettid() of the writer
+        size_t writer_depth;            // nesting of write locks
+    } items;
+
+    struct dictionary_hooks *hooks;     // pointer to external function callbacks to be called at certain points
+    struct dictionary_stats *stats;     // statistics data, when DICT_OPTION_STATS is set
 
-    NAME_VALUE *first_item;             // the double linked list base pointers
-    NAME_VALUE *last_item;
+    DICTIONARY *master;                 // the master dictionary
+    DICTIONARY *next;                   // linked list for delayed destruction (garbage collection of whole dictionaries)
 
-#ifdef DICTIONARY_WITH_AVL
-    avl_tree_type values_index;
-    NAME_VALUE *hash_base;
-    void *(*get_thread_static_name_value)(const char *name);
+    size_t version;                     // the current version of the dictionary
+                                        // it is incremented when:
+                                        //   - item added
+                                        //   - item removed
+                                        //   - item value reset
+                                        //   - conflict callback returns true
+                                        //   - function dictionary_version_increment() is called
+
+    long int entries;                   // how many items are currently in the index (the linked list may have more)
+    long int referenced_items;          // how many items of the dictionary are currently being used by 3rd parties
+    long int pending_deletion_items;    // how many items of the dictionary have been deleted, but have not been removed yet
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    netdata_mutex_t global_pointer_registry_mutex;
+    Pvoid_t global_pointer_registry;
 #endif
+};
+
+// forward definitions of functions used in reverse order in the code
+static void garbage_collect_pending_deletes(DICTIONARY *dict);
+static inline void item_linked_list_remove(DICTIONARY *dict, DICTIONARY_ITEM *item);
+static size_t dict_item_free_with_hooks(DICTIONARY *dict, DICTIONARY_ITEM *item);
+static inline const char *item_get_name(const DICTIONARY_ITEM *item);
+static inline int hashtable_delete_unsafe(DICTIONARY *dict, const char *name, size_t name_len, void *item);
+static void item_release(DICTIONARY *dict, DICTIONARY_ITEM *item);
+static bool dict_item_set_deleted(DICTIONARY *dict, DICTIONARY_ITEM *item);
+
+#define RC_ITEM_OK                         ( 0)
+#define RC_ITEM_MARKED_FOR_DELETION        (-1) // the item is marked for deletion
+#define RC_ITEM_IS_CURRENTLY_BEING_DELETED (-2) // the item is currently being deleted
+#define RC_ITEM_IS_CURRENTLY_BEING_CREATED (-3) // the item is currently being deleted
+#define RC_ITEM_IS_REFERENCED              (-4) // the item is currently referenced
+#define item_check_and_acquire(dict, item) (item_check_and_acquire_advanced(dict, item, false) == RC_ITEM_OK)
+static int item_check_and_acquire_advanced(DICTIONARY *dict, DICTIONARY_ITEM *item, bool having_index_lock);
+#define item_is_not_referenced_and_can_be_removed(dict, item) (item_is_not_referenced_and_can_be_removed_advanced(dict, item) == RC_ITEM_OK)
+static inline int item_is_not_referenced_and_can_be_removed_advanced(DICTIONARY *dict, DICTIONARY_ITEM *item);
+
+// ----------------------------------------------------------------------------
+// validate each pointer is indexed once - internal checks only
 
-#ifdef DICTIONARY_WITH_JUDYHS
-    Pvoid_t JudyHSArray;                // the hash table
+static inline void pointer_index_init(DICTIONARY *dict __maybe_unused) {
+#ifdef NETDATA_INTERNAL_CHECKS
+    netdata_mutex_init(&dict->global_pointer_registry_mutex);
+#else
+    ;
 #endif
+}
 
-    netdata_rwlock_t rwlock;            // the r/w lock when DICTIONARY_FLAG_SINGLE_THREADED is not set
+static inline void pointer_destroy_index(DICTIONARY *dict __maybe_unused) {
+#ifdef NETDATA_INTERNAL_CHECKS
+    netdata_mutex_lock(&dict->global_pointer_registry_mutex);
+    JudyHSFreeArray(&dict->global_pointer_registry, PJE0);
+    netdata_mutex_unlock(&dict->global_pointer_registry_mutex);
+#else
+    ;
+#endif
+}
+static inline void pointer_add(DICTIONARY *dict __maybe_unused, DICTIONARY_ITEM *item __maybe_unused) {
+#ifdef NETDATA_INTERNAL_CHECKS
+    netdata_mutex_lock(&dict->global_pointer_registry_mutex);
+    Pvoid_t *PValue = JudyHSIns(&dict->global_pointer_registry, &item, sizeof(void *), PJE0);
+    if(*PValue != NULL)
+        fatal("pointer already exists in registry");
+    *PValue = item;
+    netdata_mutex_unlock(&dict->global_pointer_registry_mutex);
+#else
+    ;
+#endif
+}
 
-    void (*ins_callback)(const char *name, void *value, void *data);
-    void *ins_callback_data;
+static inline void pointer_check(DICTIONARY *dict __maybe_unused, DICTIONARY_ITEM *item __maybe_unused) {
+#ifdef NETDATA_INTERNAL_CHECKS
+    netdata_mutex_lock(&dict->global_pointer_registry_mutex);
+    Pvoid_t *PValue = JudyHSGet(dict->global_pointer_registry, &item, sizeof(void *));
+    if(PValue == NULL)
+        fatal("pointer is not found in registry");
+    netdata_mutex_unlock(&dict->global_pointer_registry_mutex);
+#else
+    ;
+#endif
+}
 
-    void (*react_callback)(const char *name, void *value, void *data);
-    void *react_callback_data;
+static inline void pointer_del(DICTIONARY *dict __maybe_unused, DICTIONARY_ITEM *item __maybe_unused) {
+#ifdef NETDATA_INTERNAL_CHECKS
+    netdata_mutex_lock(&dict->global_pointer_registry_mutex);
+    int ret = JudyHSDel(&dict->global_pointer_registry, &item, sizeof(void *), PJE0);
+    if(!ret)
+        fatal("pointer to be deleted does not exist in registry");
+    netdata_mutex_unlock(&dict->global_pointer_registry_mutex);
+#else
+    ;
+#endif
+}
 
-    void (*del_callback)(const char *name, void *value, void *data);
-    void *del_callback_data;
+// ----------------------------------------------------------------------------
+// memory statistics
 
-    void (*conflict_callback)(const char *name, void *old_value, void *new_value, void *data);
-    void *conflict_callback_data;
+static inline void DICTIONARY_STATS_PLUS_MEMORY(DICTIONARY *dict, size_t key_size, size_t item_size, size_t value_size) {
+    if(key_size)
+        __atomic_fetch_add(&dict->stats->memory.indexed, (long)key_size, __ATOMIC_RELAXED);
 
-    size_t version;                   // the current version of the dictionary
-    size_t inserts;                   // how many index insertions have been performed
-    size_t deletes;                   // how many index deletions have been performed
-    size_t searches;                  // how many index searches have been performed
-    size_t resets;                    // how many times items have reset their values
-    size_t walkthroughs;              // how many walkthroughs have been done
-    long int memory;                  // how much memory the dictionary has currently allocated
-    long int entries;                 // how many items are currently in the index (the linked list may have more)
-    long int referenced_items;        // how many items of the dictionary are currently being used by 3rd parties
-    long int pending_deletion_items;  // how many items of the dictionary have been deleted, but have not been removed yet
-    int readers;                      // how many readers are currently using the dictionary
-    int writers;                      // how many writers are currently using the dictionary
-
-    size_t scratchpad_size;           // the size of the scratchpad in bytes
-    uint8_t scratchpad[];             // variable size scratchpad requested by the caller
-};
+    if(item_size)
+        __atomic_fetch_add(&dict->stats->memory.dict, (long)item_size, __ATOMIC_RELAXED);
+
+    if(value_size)
+        __atomic_fetch_add(&dict->stats->memory.values, (long)value_size, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_MINUS_MEMORY(DICTIONARY *dict, size_t key_size, size_t item_size, size_t value_size) {
+    if(key_size)
+        __atomic_fetch_sub(&dict->stats->memory.indexed, (long)key_size, __ATOMIC_RELAXED);
 
-static inline void linkedlist_namevalue_unlink_unsafe(DICTIONARY *dict, NAME_VALUE *nv);
-static size_t namevalue_destroy_unsafe(DICTIONARY *dict, NAME_VALUE *nv);
-static inline const char *namevalue_get_name(NAME_VALUE *nv);
+    if(item_size)
+        __atomic_fetch_sub(&dict->stats->memory.dict, (long)item_size, __ATOMIC_RELAXED);
+
+    if(value_size)
+        __atomic_fetch_sub(&dict->stats->memory.values, (long)value_size, __ATOMIC_RELAXED);
+}
 
 // ----------------------------------------------------------------------------
 // callbacks registration
 
-void dictionary_register_insert_callback(DICTIONARY *dict, void (*ins_callback)(const char *name, void *value, void *data), void *data) {
-    dict->ins_callback = ins_callback;
-    dict->ins_callback_data = data;
-}
+static inline void dictionary_hooks_allocate(DICTIONARY *dict) {
+    if(dict->hooks) return;
 
-void dictionary_register_delete_callback(DICTIONARY *dict, void (*del_callback)(const char *name, void *value, void *data), void *data) {
-    dict->del_callback = del_callback;
-    dict->del_callback_data = data;
-}
+    dict->hooks = callocz(1, sizeof(struct dictionary_hooks));
+    dict->hooks->links = 1;
 
-void dictionary_register_conflict_callback(DICTIONARY *dict, void (*conflict_callback)(const char *name, void *old_value, void *new_value, void *data), void *data) {
-    dict->conflict_callback = conflict_callback;
-    dict->conflict_callback_data = data;
+    DICTIONARY_STATS_PLUS_MEMORY(dict, 0, sizeof(struct dictionary_hooks), 0);
 }
 
-void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)(const char *name, void *value, void *data), void *data) {
-    dict->react_callback = react_callback;
-    dict->react_callback_data = data;
+static inline size_t dictionary_hooks_free(DICTIONARY *dict) {
+    if(!dict->hooks) return 0;
+
+    REFCOUNT links = __atomic_sub_fetch(&dict->hooks->links, 1, __ATOMIC_SEQ_CST);
+    if(links == 0) {
+        freez(dict->hooks);
+        dict->hooks = NULL;
+
+        DICTIONARY_STATS_MINUS_MEMORY(dict, 0, sizeof(struct dictionary_hooks), 0);
+        return sizeof(struct dictionary_hooks);
+    }
+
+    return 0;
 }
 
-// ----------------------------------------------------------------------------
-// dictionary statistics maintenance
+void dictionary_register_insert_callback(DICTIONARY *dict, void (*ins_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data) {
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
 
-long int dictionary_stats_allocated_memory(DICTIONARY *dict) {
-    return dict->memory;
+    dictionary_hooks_allocate(dict);
+    dict->hooks->ins_callback = ins_callback;
+    dict->hooks->ins_callback_data = data;
 }
-long int dictionary_stats_entries(DICTIONARY *dict) {
-    return dict->entries;
+
+void dictionary_register_conflict_callback(DICTIONARY *dict, bool (*conflict_callback)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data), void *data) {
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
+
+    internal_error(!(dict->options & DICT_OPTION_DONT_OVERWRITE_VALUE), "DICTIONARY: registering conflict callback without DICT_OPTION_DONT_OVERWRITE_VALUE");
+    dict->options |= DICT_OPTION_DONT_OVERWRITE_VALUE;
+
+    dictionary_hooks_allocate(dict);
+    dict->hooks->conflict_callback = conflict_callback;
+    dict->hooks->conflict_callback_data = data;
 }
-size_t dictionary_stats_version(DICTIONARY *dict) {
-    return dict->version;
+
+void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data) {
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
+
+    dictionary_hooks_allocate(dict);
+    dict->hooks->react_callback = react_callback;
+    dict->hooks->react_callback_data = data;
 }
-size_t dictionary_stats_searches(DICTIONARY *dict) {
-    return dict->searches;
+
+void dictionary_register_delete_callback(DICTIONARY *dict, void (*del_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data) {
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
+
+    dictionary_hooks_allocate(dict);
+    dict->hooks->del_callback = del_callback;
+    dict->hooks->del_callback_data = data;
 }
-size_t dictionary_stats_inserts(DICTIONARY *dict) {
-    return dict->inserts;
+
+// ----------------------------------------------------------------------------
+// dictionary statistics API
+
+size_t dictionary_version(DICTIONARY *dict) {
+    if(unlikely(!dict)) return 0;
+
+    // this is required for views to return the right number
+    garbage_collect_pending_deletes(dict);
+
+    return __atomic_load_n(&dict->version, __ATOMIC_SEQ_CST);
 }
-size_t dictionary_stats_deletes(DICTIONARY *dict) {
-    return dict->deletes;
+size_t dictionary_entries(DICTIONARY *dict) {
+    if(unlikely(!dict)) return 0;
+
+    // this is required for views to return the right number
+    garbage_collect_pending_deletes(dict);
+
+    long int entries = __atomic_load_n(&dict->entries, __ATOMIC_SEQ_CST);
+    if(entries < 0)
+        fatal("DICTIONARY: entries is negative: %ld", entries);
+
+    return entries;
 }
-size_t dictionary_stats_resets(DICTIONARY *dict) {
-    return dict->resets;
+size_t dictionary_referenced_items(DICTIONARY *dict) {
+    if(unlikely(!dict)) return 0;
+
+    long int referenced_items = __atomic_load_n(&dict->referenced_items, __ATOMIC_SEQ_CST);
+    if(referenced_items < 0)
+        fatal("DICTIONARY: referenced items is negative: %ld", referenced_items);
+
+    return referenced_items;
 }
-size_t dictionary_stats_walkthroughs(DICTIONARY *dict) {
-    return dict->walkthroughs;
+
+long int dictionary_stats_for_registry(DICTIONARY *dict) {
+    if(unlikely(!dict)) return 0;
+    return (dict->stats->memory.indexed + dict->stats->memory.dict);
 }
-size_t dictionary_stats_referenced_items(DICTIONARY *dict) {
-    return __atomic_load_n(&dict->referenced_items, __ATOMIC_SEQ_CST);
+void dictionary_version_increment(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->version, 1, __ATOMIC_SEQ_CST);
 }
 
+// ----------------------------------------------------------------------------
+// internal statistics API
+
 static inline void DICTIONARY_STATS_SEARCHES_PLUS1(DICTIONARY *dict) {
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
-        dict->searches++;
-    }
-    else {
-        __atomic_fetch_add(&dict->searches, 1, __ATOMIC_RELAXED);
-    }
+    __atomic_fetch_add(&dict->stats->ops.searches, 1, __ATOMIC_RELAXED);
 }
-static inline void DICTIONARY_STATS_ENTRIES_PLUS1(DICTIONARY *dict, size_t size) {
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
+static inline void DICTIONARY_ENTRIES_PLUS1(DICTIONARY *dict) {
+    // statistics
+    __atomic_fetch_add(&dict->stats->items.entries, 1, __ATOMIC_RELAXED);
+    __atomic_fetch_add(&dict->stats->items.referenced, 1, __ATOMIC_RELAXED);
+    __atomic_fetch_add(&dict->stats->ops.inserts, 1, __ATOMIC_RELAXED);
+
+    if(unlikely(is_dictionary_single_threaded(dict))) {
         dict->version++;
-        dict->inserts++;
         dict->entries++;
-        dict->memory += (long)size;
+        dict->referenced_items++;
+
     }
     else {
         __atomic_fetch_add(&dict->version, 1, __ATOMIC_SEQ_CST);
-        __atomic_fetch_add(&dict->inserts, 1, __ATOMIC_RELAXED);
-        __atomic_fetch_add(&dict->entries, 1, __ATOMIC_RELAXED);
-        __atomic_fetch_add(&dict->memory, (long)size, __ATOMIC_RELAXED);
+        __atomic_fetch_add(&dict->entries, 1, __ATOMIC_SEQ_CST);
+        __atomic_fetch_add(&dict->referenced_items, 1, __ATOMIC_SEQ_CST);
     }
 }
-static inline void DICTIONARY_STATS_ENTRIES_MINUS1(DICTIONARY *dict) {
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
+static inline void DICTIONARY_ENTRIES_MINUS1(DICTIONARY *dict) {
+    // statistics
+    __atomic_fetch_add(&dict->stats->ops.deletes, 1, __ATOMIC_RELAXED);
+    __atomic_fetch_sub(&dict->stats->items.entries, 1, __ATOMIC_RELAXED);
+
+    size_t entries; (void)entries;
+    if(unlikely(is_dictionary_single_threaded(dict))) {
         dict->version++;
-        dict->deletes++;
-        dict->entries--;
+        entries = dict->entries++;
     }
     else {
         __atomic_fetch_add(&dict->version, 1, __ATOMIC_SEQ_CST);
-        __atomic_fetch_add(&dict->deletes, 1, __ATOMIC_RELAXED);
-        __atomic_fetch_sub(&dict->entries, 1, __ATOMIC_RELAXED);
-    }
-}
-static inline void DICTIONARY_STATS_ENTRIES_MINUS_MEMORY(DICTIONARY *dict, size_t size) {
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
-        dict->memory -= (long)size;
-    }
-    else {
-        __atomic_fetch_sub(&dict->memory, (long)size, __ATOMIC_RELAXED);
+        entries = __atomic_fetch_sub(&dict->entries, 1, __ATOMIC_SEQ_CST);
     }
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(unlikely(entries == 0))
+        fatal("DICT: negative number of entries in dictionary created from %s() (%zu@%s)",
+              dict->creation_function,
+              dict->creation_line,
+              dict->creation_file);
+#endif
 }
-static inline void DICTIONARY_STATS_VALUE_RESETS_PLUS1(DICTIONARY *dict, size_t oldsize, size_t newsize) {
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
+static inline void DICTIONARY_VALUE_RESETS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->ops.resets, 1, __ATOMIC_RELAXED);
+
+    if(unlikely(is_dictionary_single_threaded(dict)))
         dict->version++;
-        dict->resets++;
-        dict->memory += (long)newsize;
-        dict->memory -= (long)oldsize;
-    }
-    else {
+    else
         __atomic_fetch_add(&dict->version, 1, __ATOMIC_SEQ_CST);
-        __atomic_fetch_add(&dict->resets, 1, __ATOMIC_RELAXED);
-        __atomic_fetch_add(&dict->memory, (long)newsize, __ATOMIC_RELAXED);
-        __atomic_fetch_sub(&dict->memory, (long)oldsize, __ATOMIC_RELAXED);
-    }
 }
-
+static inline void DICTIONARY_STATS_TRAVERSALS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->ops.traversals, 1, __ATOMIC_RELAXED);
+}
 static inline void DICTIONARY_STATS_WALKTHROUGHS_PLUS1(DICTIONARY *dict) {
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
-        dict->walkthroughs++;
-    }
-    else {
-        __atomic_fetch_add(&dict->walkthroughs, 1, __ATOMIC_RELAXED);
-    }
+    __atomic_fetch_add(&dict->stats->ops.walkthroughs, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_CHECK_SPINS_PLUS(DICTIONARY *dict, size_t count) {
+    __atomic_fetch_add(&dict->stats->spin_locks.use_spins, count, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_INSERT_SPINS_PLUS(DICTIONARY *dict, size_t count) {
+    __atomic_fetch_add(&dict->stats->spin_locks.insert_spins, count, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_DELETE_SPINS_PLUS(DICTIONARY *dict, size_t count) {
+    __atomic_fetch_add(&dict->stats->spin_locks.delete_spins, count, __ATOMIC_RELAXED);
 }
+static inline void DICTIONARY_STATS_SEARCH_IGNORES_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->spin_locks.search_spins, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_CALLBACK_INSERTS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->callbacks.inserts, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_CALLBACK_CONFLICTS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->callbacks.conflicts, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_CALLBACK_REACTS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->callbacks.reacts, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_CALLBACK_DELETES_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->callbacks.deletes, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_GARBAGE_COLLECTIONS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->ops.garbage_collections, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_DICT_CREATIONS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->dictionaries.active, 1, __ATOMIC_RELAXED);
+    __atomic_fetch_add(&dict->stats->ops.creations, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_DICT_DESTRUCTIONS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_sub(&dict->stats->dictionaries.active, 1, __ATOMIC_RELAXED);
+    __atomic_fetch_add(&dict->stats->ops.destructions, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_DICT_DESTROY_QUEUED_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->dictionaries.deleted, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_DICT_DESTROY_QUEUED_MINUS1(DICTIONARY *dict) {
+    __atomic_fetch_sub(&dict->stats->dictionaries.deleted, 1, __ATOMIC_RELAXED);
+}
+static inline void DICTIONARY_STATS_DICT_FLUSHES_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->ops.flushes, 1, __ATOMIC_RELAXED);
+}
+
+static inline long int DICTIONARY_REFERENCED_ITEMS_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->items.referenced, 1, __ATOMIC_RELAXED);
+
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return ++dict->referenced_items;
+    else
+        return __atomic_add_fetch(&dict->referenced_items, 1, __ATOMIC_SEQ_CST);
+}
+
+static inline long int DICTIONARY_REFERENCED_ITEMS_MINUS1(DICTIONARY *dict) {
+    __atomic_fetch_sub(&dict->stats->items.referenced, 1, __ATOMIC_RELAXED);
+
+    long int referenced_items;
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        referenced_items = --dict->referenced_items;
+    else
+        referenced_items = __atomic_sub_fetch(&dict->referenced_items, 1, __ATOMIC_SEQ_CST);
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(unlikely(referenced_items < 0))
+        fatal("DICT: negative number of referenced items (%ld) in dictionary created from %s() (%zu@%s)",
+              referenced_items,
+              dict->creation_function,
+              dict->creation_line,
+              dict->creation_file);
+#endif
 
-static inline size_t DICTIONARY_STATS_REFERENCED_ITEMS_PLUS1(DICTIONARY *dict) {
-    return __atomic_add_fetch(&dict->referenced_items, 1, __ATOMIC_SEQ_CST);
+    return referenced_items;
 }
 
-static inline size_t DICTIONARY_STATS_REFERENCED_ITEMS_MINUS1(DICTIONARY *dict) {
-    return __atomic_sub_fetch(&dict->referenced_items, 1, __ATOMIC_SEQ_CST);
+static inline long int DICTIONARY_PENDING_DELETES_PLUS1(DICTIONARY *dict) {
+    __atomic_fetch_add(&dict->stats->items.pending_deletion, 1, __ATOMIC_RELAXED);
+
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return ++dict->pending_deletion_items;
+    else
+        return __atomic_add_fetch(&dict->pending_deletion_items, 1, __ATOMIC_SEQ_CST);
 }
 
-static inline size_t DICTIONARY_STATS_PENDING_DELETES_PLUS1(DICTIONARY *dict) {
-    return __atomic_add_fetch(&dict->pending_deletion_items, 1, __ATOMIC_SEQ_CST);
+static inline long int DICTIONARY_PENDING_DELETES_MINUS1(DICTIONARY *dict) {
+    __atomic_fetch_sub(&dict->stats->items.pending_deletion, 1, __ATOMIC_RELAXED);
+
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return --dict->pending_deletion_items;
+    else
+        return __atomic_sub_fetch(&dict->pending_deletion_items, 1, __ATOMIC_SEQ_CST);
 }
 
-static inline size_t DICTIONARY_STATS_PENDING_DELETES_MINUS1(DICTIONARY *dict) {
-    return __atomic_sub_fetch(&dict->pending_deletion_items, 1, __ATOMIC_SEQ_CST);
+static inline long int DICTIONARY_PENDING_DELETES_GET(DICTIONARY *dict) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return dict->pending_deletion_items;
+    else
+        return __atomic_load_n(&dict->pending_deletion_items, __ATOMIC_SEQ_CST);
 }
 
-static inline size_t DICTIONARY_STATS_PENDING_DELETES_GET(DICTIONARY *dict) {
-    return __atomic_load_n(&dict->pending_deletion_items, __ATOMIC_SEQ_CST);
+static inline REFCOUNT DICTIONARY_ITEM_REFCOUNT_GET(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    if(unlikely(dict && is_dictionary_single_threaded(dict))) // this is an exception, dict can be null
+        return item->refcount;
+    else
+        return (REFCOUNT)__atomic_load_n(&item->refcount, __ATOMIC_SEQ_CST);
 }
 
-static inline int DICTIONARY_NAME_VALUE_REFCOUNT_GET(NAME_VALUE *nv) {
-    return __atomic_load_n(&nv->refcount, __ATOMIC_SEQ_CST);
+static inline REFCOUNT DICTIONARY_ITEM_REFCOUNT_GET_SOLE(DICTIONARY_ITEM *item) {
+    return (REFCOUNT)__atomic_load_n(&item->refcount, __ATOMIC_SEQ_CST);
 }
 
 // ----------------------------------------------------------------------------
-// garbage collector
-// it is called every time someone gets a write lock to the dictionary
+// callbacks execution
 
-static void garbage_collect_pending_deletes_unsafe(DICTIONARY *dict) {
-    if(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS)) return;
+static void dictionary_execute_insert_callback(DICTIONARY *dict, DICTIONARY_ITEM *item, void *constructor_data) {
+    if(likely(!dict->hooks || !dict->hooks->ins_callback))
+        return;
 
-    if(likely(!DICTIONARY_STATS_PENDING_DELETES_GET(dict))) return;
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
 
-    NAME_VALUE *nv = dict->first_item;
-    while(nv) {
-        if((nv->flags & NAME_VALUE_FLAG_DELETED) && DICTIONARY_NAME_VALUE_REFCOUNT_GET(nv) == 0) {
-            NAME_VALUE *nv_next = nv->next;
+    internal_error(false,
+                   "DICTIONARY: Running insert callback on item '%s' of dictionary created from %s() %zu@%s.",
+                   item_get_name(item),
+                   dict->creation_function,
+                   dict->creation_line,
+                   dict->creation_file);
 
-            linkedlist_namevalue_unlink_unsafe(dict, nv);
-            namevalue_destroy_unsafe(dict, nv);
+    DICTIONARY_STATS_CALLBACK_INSERTS_PLUS1(dict);
+    dict->hooks->ins_callback(item, item->shared->value, constructor_data?constructor_data:dict->hooks->ins_callback_data);
+}
 
-            size_t pending = DICTIONARY_STATS_PENDING_DELETES_MINUS1(dict);
-            if(!pending) break;
+static bool dictionary_execute_conflict_callback(DICTIONARY *dict, DICTIONARY_ITEM *item, void *new_value, void *constructor_data) {
+    if(likely(!dict->hooks || !dict->hooks->conflict_callback))
+        return false;
 
-            nv = nv_next;
-        }
-        else
-            nv = nv->next;
-    }
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
+
+    internal_error(false,
+                   "DICTIONARY: Running conflict callback on item '%s' of dictionary created from %s() %zu@%s.",
+                   item_get_name(item),
+                   dict->creation_function,
+                   dict->creation_line,
+                   dict->creation_file);
+
+    DICTIONARY_STATS_CALLBACK_CONFLICTS_PLUS1(dict);
+    return dict->hooks->conflict_callback(
+        item, item->shared->value, new_value,
+        constructor_data ? constructor_data : dict->hooks->conflict_callback_data);
 }
 
-// ----------------------------------------------------------------------------
-// dictionary locks
+static void dictionary_execute_react_callback(DICTIONARY *dict, DICTIONARY_ITEM *item, void *constructor_data) {
+    if(likely(!dict->hooks || !dict->hooks->react_callback))
+        return;
+
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: called %s() on a view.", __FUNCTION__ );
+
+    internal_error(false,
+                   "DICTIONARY: Running react callback on item '%s' of dictionary created from %s() %zu@%s.",
+                   item_get_name(item),
+                   dict->creation_function,
+                   dict->creation_line,
+                   dict->creation_file);
+
+    DICTIONARY_STATS_CALLBACK_REACTS_PLUS1(dict);
+    dict->hooks->react_callback(item, item->shared->value,
+                                constructor_data?constructor_data:dict->hooks->react_callback_data);
+}
 
-static inline size_t dictionary_lock_init(DICTIONARY *dict) {
-    if(likely(!(dict->flags & DICTIONARY_FLAG_SINGLE_THREADED))) {
-        netdata_rwlock_init(&dict->rwlock);
+static void dictionary_execute_delete_callback(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    if(likely(!dict->hooks || !dict->hooks->del_callback))
+        return;
+
+    // We may execute the delete callback on items deleted from a view,
+    // because we may have references to it, after the master is gone
+    // so, the shared structure will remain until the last reference is released.
 
-        if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS)
-            dict->flags &= ~DICTIONARY_FLAG_EXCLUSIVE_ACCESS;
+    internal_error(false,
+                   "DICTIONARY: Running delete callback on item '%s' of dictionary created from %s() %zu@%s.",
+                   item_get_name(item),
+                   dict->creation_function,
+                   dict->creation_line,
+                   dict->creation_file);
+
+    DICTIONARY_STATS_CALLBACK_DELETES_PLUS1(dict);
+    dict->hooks->del_callback(item, item->shared->value, dict->hooks->del_callback_data);
+}
+
+// ----------------------------------------------------------------------------
+// dictionary locks
 
+static inline size_t dictionary_locks_init(DICTIONARY *dict) {
+    if(likely(!is_dictionary_single_threaded(dict))) {
+        netdata_rwlock_init(&dict->index.rwlock);
+        netdata_rwlock_init(&dict->items.rwlock);
         return 0;
     }
-
-    // we are single threaded
-    dict->flags |= DICTIONARY_FLAG_EXCLUSIVE_ACCESS;
     return 0;
 }
 
-static inline size_t dictionary_lock_free(DICTIONARY *dict) {
-    if(likely(!(dict->flags & DICTIONARY_FLAG_SINGLE_THREADED))) {
-        netdata_rwlock_destroy(&dict->rwlock);
+static inline size_t dictionary_locks_destroy(DICTIONARY *dict) {
+    if(likely(!is_dictionary_single_threaded(dict))) {
+        netdata_rwlock_destroy(&dict->index.rwlock);
+        netdata_rwlock_destroy(&dict->items.rwlock);
         return 0;
     }
     return 0;
 }
 
-static void dictionary_lock(DICTIONARY *dict, char rw) {
-    if(rw == 'u' || rw == 'U') return;
+static inline void ll_recursive_lock_set_thread_as_writer(DICTIONARY *dict) {
+    pid_t expected = 0, desired = gettid();
+    if(!__atomic_compare_exchange_n(&dict->items.writer_pid, &expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST))
+        fatal("DICTIONARY: Cannot set thread %d as exclusive writer, expected %d, desired %d, found %d.", gettid(), expected, desired, __atomic_load_n(&dict->items.writer_pid, __ATOMIC_SEQ_CST));
+}
 
-    if(rw == 'r' || rw == 'R') {
-        // read lock
-        __atomic_add_fetch(&dict->readers, 1, __ATOMIC_RELAXED);
-    }
-    else {
-        // write lock
-        __atomic_add_fetch(&dict->writers, 1, __ATOMIC_RELAXED);
-    }
+static inline void ll_recursive_unlock_unset_thread_writer(DICTIONARY *dict) {
+    pid_t expected = gettid(), desired = 0;
+    if(!__atomic_compare_exchange_n(&dict->items.writer_pid, &expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST))
+        fatal("DICTIONARY: Cannot unset thread %d as exclusive writer, expected %d, desired %d, found %d.", gettid(), expected, desired, __atomic_load_n(&dict->items.writer_pid, __ATOMIC_SEQ_CST));
+}
+
+static inline bool ll_recursive_lock_is_thread_the_writer(DICTIONARY *dict) {
+    pid_t tid = gettid();
+    return tid > 0 && tid == __atomic_load_n(&dict->items.writer_pid, __ATOMIC_SEQ_CST);
+}
 
-    if(likely(dict->flags & DICTIONARY_FLAG_SINGLE_THREADED))
+static void ll_recursive_lock(DICTIONARY *dict, char rw) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
         return;
 
-    if(rw == 'r' || rw == 'R') {
-        // read lock
-        netdata_rwlock_rdlock(&dict->rwlock);
+    if(ll_recursive_lock_is_thread_the_writer(dict)) {
+        dict->items.writer_depth++;
+        return;
+    }
 
-        if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS) {
-            internal_error(true, "DICTIONARY: left-over exclusive access to dictionary created by %s (%zu@%s) found", dict->creation_function, dict->creation_line, dict->creation_file);
-            dict->flags &= ~DICTIONARY_FLAG_EXCLUSIVE_ACCESS;
-        }
+    if(rw == DICTIONARY_LOCK_READ || rw == DICTIONARY_LOCK_REENTRANT || rw == 'R') {
+        // read lock
+        netdata_rwlock_rdlock(&dict->items.rwlock);
     }
     else {
         // write lock
-        netdata_rwlock_wrlock(&dict->rwlock);
-
-        dict->flags |= DICTIONARY_FLAG_EXCLUSIVE_ACCESS;
+        netdata_rwlock_wrlock(&dict->items.rwlock);
+        ll_recursive_lock_set_thread_as_writer(dict);
     }
 }
 
-static void dictionary_unlock(DICTIONARY *dict, char rw) {
-    if(rw == 'u' || rw == 'U') return;
+static void ll_recursive_unlock(DICTIONARY *dict, char rw) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return;
 
-    if(rw == 'r' || rw == 'R') {
+    if(ll_recursive_lock_is_thread_the_writer(dict) && dict->items.writer_depth > 0) {
+        dict->items.writer_depth--;
+        return;
+    }
+
+    if(rw == DICTIONARY_LOCK_READ || rw == DICTIONARY_LOCK_REENTRANT || rw == 'R') {
         // read unlock
-        __atomic_sub_fetch(&dict->readers, 1, __ATOMIC_RELAXED);
+
+        netdata_rwlock_unlock(&dict->items.rwlock);
     }
     else {
         // write unlock
-        garbage_collect_pending_deletes_unsafe(dict);
-        __atomic_sub_fetch(&dict->writers, 1, __ATOMIC_RELAXED);
+
+        ll_recursive_unlock_unset_thread_writer(dict);
+
+        netdata_rwlock_unlock(&dict->items.rwlock);
     }
+}
 
-    if(likely(dict->flags & DICTIONARY_FLAG_SINGLE_THREADED))
+void dictionary_write_lock(DICTIONARY *dict) {
+    ll_recursive_lock(dict, DICTIONARY_LOCK_WRITE);
+}
+void dictionary_write_unlock(DICTIONARY *dict) {
+    ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
+}
+
+static inline void dictionary_index_lock_rdlock(DICTIONARY *dict) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
         return;
 
-    if(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS)
-        dict->flags &= ~DICTIONARY_FLAG_EXCLUSIVE_ACCESS;
+    netdata_rwlock_rdlock(&dict->index.rwlock);
+}
+
+static inline void dictionary_index_rdlock_unlock(DICTIONARY *dict) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return;
 
-    netdata_rwlock_unlock(&dict->rwlock);
+    netdata_rwlock_unlock(&dict->index.rwlock);
 }
 
-// ----------------------------------------------------------------------------
-// deferred deletions
+static inline void dictionary_index_lock_wrlock(DICTIONARY *dict) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return;
 
-void dictionary_defer_all_deletions_unsafe(DICTIONARY *dict, char rw) {
-    if(rw == 'r' || rw == 'R') {
-        // read locked - no need to defer deletions
-        ;
-    }
-    else {
-        // write locked - defer deletions
-        dict->flags |= DICTIONARY_FLAG_DEFER_ALL_DELETIONS;
-    }
+    netdata_rwlock_wrlock(&dict->index.rwlock);
 }
+static inline void dictionary_index_wrlock_unlock(DICTIONARY *dict) {
+    if(unlikely(is_dictionary_single_threaded(dict)))
+        return;
 
-void dictionary_restore_all_deletions_unsafe(DICTIONARY *dict, char rw) {
-    if(rw == 'r' || rw == 'R') {
-        // read locked - no need to defer deletions
-        internal_error(dict->flags & DICTIONARY_FLAG_DEFER_ALL_DELETIONS, "DICTIONARY: deletions are deferred on a read lock");
-    }
-    else {
-        // write locked - defer deletions
-        if(dict->flags & DICTIONARY_FLAG_DEFER_ALL_DELETIONS)
-            dict->flags &= ~DICTIONARY_FLAG_DEFER_ALL_DELETIONS;
+    netdata_rwlock_unlock(&dict->index.rwlock);
+}
+
+// ----------------------------------------------------------------------------
+// items garbage collector
+
+static void garbage_collect_pending_deletes(DICTIONARY *dict) {
+    usec_t last_master_deletion_us = dict->hooks?__atomic_load_n(&dict->hooks->last_master_deletion_us, __ATOMIC_SEQ_CST):0;
+    usec_t last_gc_run_us = __atomic_load_n(&dict->last_gc_run_us, __ATOMIC_SEQ_CST);
+
+    bool is_view = is_view_dictionary(dict);
+
+    if(likely(!(
+            DICTIONARY_PENDING_DELETES_GET(dict) > 0 ||
+            (is_view && last_master_deletion_us > last_gc_run_us)
+            )))
+        return;
+
+    ll_recursive_lock(dict, DICTIONARY_LOCK_WRITE);
+
+    __atomic_store_n(&dict->last_gc_run_us, now_realtime_usec(), __ATOMIC_SEQ_CST);
+
+    if(is_view)
+        dictionary_index_lock_wrlock(dict);
+
+    DICTIONARY_STATS_GARBAGE_COLLECTIONS_PLUS1(dict);
+
+    size_t deleted = 0, pending = 0, examined = 0;
+    DICTIONARY_ITEM *item = dict->items.list, *item_next;
+    while(item) {
+        examined++;
+
+        // this will cleanup
+        item_next = item->next;
+        int rc = item_check_and_acquire_advanced(dict, item, is_view);
+
+        if(rc == RC_ITEM_MARKED_FOR_DELETION) {
+            // we didn't get a reference
+
+            if(item_is_not_referenced_and_can_be_removed(dict, item)) {
+                DOUBLE_LINKED_LIST_REMOVE_UNSAFE(dict->items.list, item, prev, next);
+                dict_item_free_with_hooks(dict, item);
+                deleted++;
+
+                pending = DICTIONARY_PENDING_DELETES_MINUS1(dict);
+                if (!pending)
+                    break;
+            }
+        }
+        else if(rc == RC_ITEM_IS_CURRENTLY_BEING_DELETED)
+            ; // do not touch this item (we didn't get a reference)
+
+        else if(rc == RC_ITEM_OK)
+            item_release(dict, item);
+
+        item = item_next;
     }
+
+    if(is_view)
+        dictionary_index_wrlock_unlock(dict);
+
+    ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
+
+    (void)deleted;
+    (void)examined;
+
+    internal_error(false, "DICTIONARY: garbage collected dictionary created by %s (%zu@%s), examined %zu items, deleted %zu items, still pending %zu items",
+                   dict->creation_function, dict->creation_line, dict->creation_file, examined, deleted, pending);
+
 }
 
 // ----------------------------------------------------------------------------
@@ -413,144 +840,248 @@ static inline size_t reference_counter_free(DICTIONARY *dict) {
     return 0;
 }
 
-static int reference_counter_increase(NAME_VALUE *nv) {
-    int refcount = __atomic_add_fetch(&nv->refcount, 1, __ATOMIC_SEQ_CST);
-    if(refcount == 1)
-        fatal("DICTIONARY: request to dup item '%s' but its reference counter was zero", namevalue_get_name(nv));
-    return refcount;
-}
+static void item_acquire(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    REFCOUNT refcount;
 
-static int reference_counter_acquire(DICTIONARY *dict, NAME_VALUE *nv) {
-    int refcount;
-    if(likely(dict->flags & DICTIONARY_FLAG_SINGLE_THREADED))
-        refcount = ++nv->refcount;
-    else
-        refcount = __atomic_add_fetch(&nv->refcount, 1, __ATOMIC_SEQ_CST);
+    if(unlikely(is_dictionary_single_threaded(dict))) {
+        refcount = ++item->refcount;
+    }
+    else {
+        // increment the refcount
+        refcount = __atomic_add_fetch(&item->refcount, 1, __ATOMIC_SEQ_CST);
+    }
+
+    if(refcount <= 0) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to acquire item which is deleted (refcount = %d): "
+            "'%s' on dictionary created by %s() (%zu@%s)",
+            refcount - 1,
+            item_get_name(item),
+            dict->creation_function,
+            dict->creation_line,
+            dict->creation_file);
+
+        fatal(
+            "DICTIONARY: request to acquire item '%s', which is deleted (refcount = %d)!",
+            item_get_name(item),
+            refcount - 1);
+    }
 
     if(refcount == 1) {
         // referenced items counts number of unique items referenced
         // so, we increase it only when refcount == 1
-        DICTIONARY_STATS_REFERENCED_ITEMS_PLUS1(dict);
+        DICTIONARY_REFERENCED_ITEMS_PLUS1(dict);
 
         // if this is a deleted item, but the counter increased to 1
         // we need to remove it from the pending items to delete
-        if (nv->flags & NAME_VALUE_FLAG_DELETED)
-            DICTIONARY_STATS_PENDING_DELETES_MINUS1(dict);
+        if(item_flag_check(item, ITEM_FLAG_DELETED))
+            DICTIONARY_PENDING_DELETES_MINUS1(dict);
     }
-
-    return refcount;
 }
 
-static uint32_t reference_counter_release(DICTIONARY *dict, NAME_VALUE *nv, bool can_get_write_lock) {
+static void item_release(DICTIONARY *dict, DICTIONARY_ITEM *item) {
     // this function may be called without any lock on the dictionary
-    // or even when someone else has a write lock on the dictionary
-    // so, we cannot check for EXCLUSIVE ACCESS
+    // or even when someone else has write lock on the dictionary
 
-    uint32_t refcount;
-    if(likely(dict->flags & DICTIONARY_FLAG_SINGLE_THREADED))
-        refcount = nv->refcount--;
-    else
-        refcount = __atomic_fetch_sub(&nv->refcount, 1, __ATOMIC_SEQ_CST);
+    bool is_deleted;
+    REFCOUNT refcount;
 
-    if(refcount == 0) {
-        internal_error(true, "DICTIONARY: attempted to release item without references: '%s' on dictionary created by %s() (%zu@%s)", namevalue_get_name(nv), dict->creation_function, dict->creation_line, dict->creation_file);
-        fatal("DICTIONARY: attempted to release item without references: '%s'", namevalue_get_name(nv));
+    if(unlikely(is_dictionary_single_threaded(dict))) {
+        is_deleted = item->flags & ITEM_FLAG_DELETED;
+        refcount = --item->refcount;
     }
+    else {
+        // get the flags before decrementing any reference counters
+        // (the other way around may lead to use-after-free)
+        is_deleted = item_flag_check(item, ITEM_FLAG_DELETED);
 
-    if(refcount == 1) {
-        if((nv->flags & NAME_VALUE_FLAG_DELETED))
-            DICTIONARY_STATS_PENDING_DELETES_PLUS1(dict);
+        // decrement the refcount
+        refcount = __atomic_sub_fetch(&item->refcount, 1, __ATOMIC_SEQ_CST);
+    }
+
+    if(refcount < 0) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to release item without references (refcount = %d): "
+            "'%s' on dictionary created by %s() (%zu@%s)",
+            refcount + 1,
+            item_get_name(item),
+            dict->creation_function,
+            dict->creation_line,
+            dict->creation_file);
+
+        fatal(
+            "DICTIONARY: attempted to release item '%s' without references (refcount = %d)",
+            item_get_name(item),
+            refcount + 1);
+    }
+
+    if(refcount == 0) {
+
+        if(is_deleted)
+            DICTIONARY_PENDING_DELETES_PLUS1(dict);
 
         // referenced items counts number of unique items referenced
         // so, we decrease it only when refcount == 0
-        DICTIONARY_STATS_REFERENCED_ITEMS_MINUS1(dict);
+        DICTIONARY_REFERENCED_ITEMS_MINUS1(dict);
     }
+}
+
+static int item_check_and_acquire_advanced(DICTIONARY *dict, DICTIONARY_ITEM *item, bool having_index_lock) {
+    size_t spins = 0;
+    REFCOUNT refcount, desired;
+
+    int ret = RC_ITEM_OK;
+
+    do {
+        spins++;
+
+        refcount = DICTIONARY_ITEM_REFCOUNT_GET(dict, item);
+
+        if(refcount < 0) {
+            // we can't use this item
+            ret = RC_ITEM_IS_CURRENTLY_BEING_DELETED;
+            break;
+        }
+
+        if(item_flag_check(item, ITEM_FLAG_DELETED)) {
+            // we can't use this item
+            ret = RC_ITEM_MARKED_FOR_DELETION;
+            break;
+        }
+
+        desired = refcount + 1;
+
+    } while(!__atomic_compare_exchange_n(&item->refcount, &refcount, desired,
+                                          false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST));
+
+    // if ret == ITEM_OK, we acquired the item
+
+    if(ret == RC_ITEM_OK) {
+        if (is_view_dictionary(dict) &&
+            item_shared_flag_check(item, ITEM_FLAG_DELETED) &&
+            !item_flag_check(item, ITEM_FLAG_DELETED)) {
+            // but, we can't use this item
+
+            if (having_index_lock) {
+                // delete it from the hashtable
+                if(hashtable_delete_unsafe(dict, item_get_name(item), item->key_len, item) == 0)
+                    error("DICTIONARY: INTERNAL ERROR VIEW: tried to delete item with name '%s', name_len %u that is not in the index", item_get_name(item), (KEY_LEN_TYPE)(item->key_len - 1));
+                else
+                    pointer_del(dict, item);
+
+                // mark it in our dictionary as deleted too
+                // this is safe to be done here, because we have got
+                // a reference counter on item
+                dict_item_set_deleted(dict, item);
+
+                // decrement the refcount we incremented above
+                if (__atomic_sub_fetch(&item->refcount, 1, __ATOMIC_SEQ_CST) == 0) {
+                    // this is a deleted item, and we are the last one
+                    DICTIONARY_PENDING_DELETES_PLUS1(dict);
+                }
+
+                // do not touch the item below this point
+            } else {
+                // this is traversal / walkthrough
+                // decrement the refcount we incremented above
+                __atomic_sub_fetch(&item->refcount, 1, __ATOMIC_SEQ_CST);
+            }
 
-    if(can_get_write_lock && DICTIONARY_STATS_PENDING_DELETES_GET(dict)) {
-        // we can garbage collect now
+            return RC_ITEM_MARKED_FOR_DELETION;
+        }
 
-        dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
-        garbage_collect_pending_deletes_unsafe(dict);
-        dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
+        if(desired == 1)
+            DICTIONARY_REFERENCED_ITEMS_PLUS1(dict);
     }
 
-    return refcount;
+
+    if(unlikely(spins > 1 && dict->stats))
+        DICTIONARY_STATS_CHECK_SPINS_PLUS(dict, spins - 1);
+
+    return ret;
 }
 
-// ----------------------------------------------------------------------------
-// hash table
+// if a dictionary item can be deleted, return true, otherwise return false
+// we use the private reference counter
+static inline int item_is_not_referenced_and_can_be_removed_advanced(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    // if we can set refcount to REFCOUNT_DELETING, we can delete this item
 
-#ifdef DICTIONARY_WITH_AVL
-static inline const char *namevalue_get_name(NAME_VALUE *nv);
+    size_t spins = 0;
+    REFCOUNT refcount, desired = REFCOUNT_DELETING;
 
-static int name_value_compare(void* a, void* b) {
-    return strcmp(namevalue_get_name((NAME_VALUE *)a), namevalue_get_name((NAME_VALUE *)b));
-}
+    int ret = RC_ITEM_OK;
 
-static void *get_thread_static_name_value(const char *name) {
-    static __thread NAME_VALUE tmp = { 0 };
-    tmp.flags = NAME_VALUE_FLAG_NONE;
-    tmp.caller_name = (char *)name;
-    return &tmp;
-}
+    do {
+        spins++;
 
-static void hashtable_init_unsafe(DICTIONARY *dict) {
-    avl_init(&dict->values_index, name_value_compare);
-    dict->get_thread_static_name_value = get_thread_static_name_value;
-}
+        refcount = DICTIONARY_ITEM_REFCOUNT_GET(dict, item);
 
-static size_t hashtable_destroy_unsafe(DICTIONARY *dict) {
-    (void)dict;
-    return 0;
-}
+        if(refcount < 0) {
+            // we can't use this item
+            ret = RC_ITEM_IS_CURRENTLY_BEING_DELETED;
+            break;
+        }
 
-static inline int hashtable_delete_unsafe(DICTIONARY *dict, const char *name, size_t name_len, void *nv) {
-    (void)name;
-    (void)name_len;
+        if(refcount > 0) {
+            // we can't delete this
+            ret = RC_ITEM_IS_REFERENCED;
+            break;
+        }
 
-    if(unlikely(avl_remove(&(dict->values_index), (avl_t *)(nv)) != (avl_t *)nv))
-        return 0;
+        if(item_flag_check(item, ITEM_FLAG_BEING_CREATED)) {
+            // we can't use this item
+            ret = RC_ITEM_IS_CURRENTLY_BEING_CREATED;
+            break;
+        }
+    } while(!__atomic_compare_exchange_n(&item->refcount, &refcount, desired,
+                                                         false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST));
 
-    return 1;
-}
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(ret == RC_ITEM_OK)
+        item->deleter_pid = gettid();
+#endif
 
-static inline NAME_VALUE *hashtable_get_unsafe(DICTIONARY *dict, const char *name, size_t name_len) {
-    (void)name_len;
+    if(unlikely(spins > 1 && dict->stats))
+        DICTIONARY_STATS_DELETE_SPINS_PLUS(dict, spins - 1);
 
-    void *tmp = dict->get_thread_static_name_value(name);
-    return (NAME_VALUE *)avl_search(&(dict->values_index), (avl_t *)tmp);
+    return ret;
 }
 
-static inline NAME_VALUE **hashtable_insert_unsafe(DICTIONARY *dict, const char *name, size_t name_len) {
-    // AVL needs a NAME_VALUE to insert into the dictionary but we don't have it yet.
-    // So, the only thing we can do, is return an existing one if it is already there.
-    // Returning NULL will make the caller thing we added it, will allocate one
-    // and will call hashtable_inserted_name_value_unsafe(), at which we will do
-    // the actual indexing.
+// if a dictionary item can be freed, return true, otherwise return false
+// we use the shared reference counter
+static inline bool item_shared_release_and_check_if_it_can_be_freed(DICTIONARY *dict __maybe_unused, DICTIONARY_ITEM *item) {
+    // if we can set refcount to REFCOUNT_DELETING, we can delete this item
 
-    dict->hash_base = hashtable_get_unsafe(dict, name, name_len);
-    return &dict->hash_base;
-}
+    REFCOUNT links = __atomic_sub_fetch(&item->shared->links, 1, __ATOMIC_SEQ_CST);
+    if(links == 0 && __atomic_compare_exchange_n(&item->shared->links, &links, REFCOUNT_DELETING,
+                                                     false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
 
-static inline void hashtable_inserted_name_value_unsafe(DICTIONARY *dict, void *nv) {
-    // we have our new NAME_VALUE object.
-    // Let's index it.
+        // we can delete it
+        return true;
+    }
 
-    if(unlikely(avl_insert(&((dict)->values_index), (avl_t *)(nv)) != (avl_t *)nv))
-        error("dictionary: INTERNAL ERROR: duplicate insertion to dictionary.");
+    // we can't delete it
+    return false;
 }
-#endif
 
-#ifdef DICTIONARY_WITH_JUDYHS
-static void hashtable_init_unsafe(DICTIONARY *dict) {
-    dict->JudyHSArray = NULL;
+
+// ----------------------------------------------------------------------------
+// hash table operations
+
+static size_t hashtable_init_unsafe(DICTIONARY *dict) {
+    dict->index.JudyHSArray = NULL;
+    return 0;
 }
 
 static size_t hashtable_destroy_unsafe(DICTIONARY *dict) {
-    if(unlikely(!dict->JudyHSArray)) return 0;
+    if(unlikely(!dict->index.JudyHSArray)) return 0;
+
+    pointer_destroy_index(dict);
 
     JError_t J_Error;
-    Word_t ret = JudyHSFreeArray(&dict->JudyHSArray, &J_Error);
+    Word_t ret = JudyHSFreeArray(&dict->index.JudyHSArray, &J_Error);
     if(unlikely(ret == (Word_t) JERR)) {
         error("DICTIONARY: Cannot destroy JudyHS, JU_ERRNO_* == %u, ID == %d",
               JU_ERRNO(&J_Error), JU_ERRID(&J_Error));
@@ -558,17 +1089,15 @@ static size_t hashtable_destroy_unsafe(DICTIONARY *dict) {
 
     debug(D_DICTIONARY, "Dictionary: hash table freed %lu bytes", ret);
 
-    dict->JudyHSArray = NULL;
+    dict->index.JudyHSArray = NULL;
     return (size_t)ret;
 }
 
-static inline NAME_VALUE **hashtable_insert_unsafe(DICTIONARY *dict, const char *name, size_t name_len) {
-    internal_error(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS), "DICTIONARY: inserting item from the index without exclusive access to the dictionary created by %s() (%zu@%s)", dict->creation_function, dict->creation_line, dict->creation_file);
-
+static inline void **hashtable_insert_unsafe(DICTIONARY *dict, const char *name, size_t name_len) {
     JError_t J_Error;
-    Pvoid_t *Rc = JudyHSIns(&dict->JudyHSArray, (void *)name, name_len, &J_Error);
+    Pvoid_t *Rc = JudyHSIns(&dict->index.JudyHSArray, (void *)name, name_len, &J_Error);
     if (unlikely(Rc == PJERR)) {
-        fatal("DICTIONARY: Cannot insert entry with name '%s' to JudyHS, JU_ERRNO_* == %u, ID == %d",
+        error("DICTIONARY: Cannot insert entry with name '%s' to JudyHS, JU_ERRNO_* == %u, ID == %d",
               name, JU_ERRNO(&J_Error), JU_ERRID(&J_Error));
     }
 
@@ -579,17 +1108,15 @@ static inline NAME_VALUE **hashtable_insert_unsafe(DICTIONARY *dict, const char
     // put anything needed at the value of the index.
     // The pointer to pointer we return has to be used before
     // any other operation that may change the index (insert/delete).
-    return (NAME_VALUE **)Rc;
+    return Rc;
 }
 
-static inline int hashtable_delete_unsafe(DICTIONARY *dict, const char *name, size_t name_len, void *nv) {
-    internal_error(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS), "DICTIONARY: deleting item from the index without exclusive access to the dictionary created by %s() (%zu@%s)", dict->creation_function, dict->creation_line, dict->creation_file);
-
-    (void)nv;
-    if(unlikely(!dict->JudyHSArray)) return 0;
+static inline int hashtable_delete_unsafe(DICTIONARY *dict, const char *name, size_t name_len, void *item) {
+    (void)item;
+    if(unlikely(!dict->index.JudyHSArray)) return 0;
 
     JError_t J_Error;
-    int ret = JudyHSDel(&dict->JudyHSArray, (void *)name, name_len, &J_Error);
+    int ret = JudyHSDel(&dict->index.JudyHSArray, (void *)name, name_len, &J_Error);
     if(unlikely(ret == JERR)) {
         error("DICTIONARY: Cannot delete entry with name '%s' from JudyHS, JU_ERRNO_* == %u, ID == %d", name,
               JU_ERRNO(&J_Error), JU_ERRID(&J_Error));
@@ -609,16 +1136,17 @@ static inline int hashtable_delete_unsafe(DICTIONARY *dict, const char *name, si
     }
 }
 
-static inline NAME_VALUE *hashtable_get_unsafe(DICTIONARY *dict, const char *name, size_t name_len) {
-    if(unlikely(!dict->JudyHSArray)) return NULL;
+static inline DICTIONARY_ITEM *hashtable_get_unsafe(DICTIONARY *dict, const char *name, size_t name_len) {
+    if(unlikely(!dict->index.JudyHSArray)) return NULL;
 
     DICTIONARY_STATS_SEARCHES_PLUS1(dict);
 
     Pvoid_t *Rc;
-    Rc = JudyHSGet(dict->JudyHSArray, (void *)name, name_len);
+    Rc = JudyHSGet(dict->index.JudyHSArray, (void *)name, name_len);
     if(likely(Rc)) {
         // found in the hash table
-        return (NAME_VALUE *)*Rc;
+        pointer_check(dict, (DICTIONARY_ITEM *)*Rc);
+        return (DICTIONARY_ITEM *)*Rc;
     }
     else {
         // not found in the hash table
@@ -626,345 +1154,419 @@ static inline NAME_VALUE *hashtable_get_unsafe(DICTIONARY *dict, const char *nam
     }
 }
 
-static inline void hashtable_inserted_name_value_unsafe(DICTIONARY *dict, void *nv) {
+static inline void hashtable_inserted_item_unsafe(DICTIONARY *dict, void *item) {
     (void)dict;
-    (void)nv;
+    (void)item;
+
+    // this is called just after an item is successfully inserted to the hashtable
+    // we don't need this for judy, but we may need it if we integrate more hash tables
+
     ;
 }
 
-#endif // DICTIONARY_WITH_JUDYHS
-
 // ----------------------------------------------------------------------------
 // linked list management
 
-static inline void linkedlist_namevalue_link_unsafe(DICTIONARY *dict, NAME_VALUE *nv) {
-    internal_error(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS), "DICTIONARY: adding item to the linked-list without exclusive access to the dictionary created by %s() (%zu@%s)", dict->creation_function, dict->creation_line, dict->creation_file);
+static inline void item_linked_list_add(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    ll_recursive_lock(dict, DICTIONARY_LOCK_WRITE);
 
-    if (unlikely(!dict->first_item)) {
-        // we are the only ones here
-        nv->next = NULL;
-        nv->prev = NULL;
-        dict->first_item = dict->last_item = nv;
-        return;
-    }
+    if(dict->options & DICT_OPTION_ADD_IN_FRONT)
+        DOUBLE_LINKED_LIST_PREPEND_UNSAFE(dict->items.list, item, prev, next);
+    else
+        DOUBLE_LINKED_LIST_APPEND_UNSAFE(dict->items.list, item, prev, next);
 
-    if(dict->flags & DICTIONARY_FLAG_ADD_IN_FRONT) {
-        // add it at the beginning
-        nv->prev = NULL;
-        nv->next = dict->first_item;
+#ifdef NETDATA_INTERNAL_CHECKS
+    item->ll_adder_pid = gettid();
+#endif
 
-        if (likely(nv->next)) nv->next->prev = nv;
-        dict->first_item = nv;
-    }
-    else {
-        // add it at the end
-        nv->next = NULL;
-        nv->prev = dict->last_item;
+    // clear the BEING created flag,
+    // after it has been inserted into the linked list
+    item_flag_clear(item, ITEM_FLAG_BEING_CREATED);
 
-        if (likely(nv->prev)) nv->prev->next = nv;
-        dict->last_item = nv;
-    }
+    garbage_collect_pending_deletes(dict);
+    ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
 }
 
-static inline void linkedlist_namevalue_unlink_unsafe(DICTIONARY *dict, NAME_VALUE *nv) {
-    internal_error(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS), "DICTIONARY: removing item from the linked-list without exclusive access to the dictionary created by %s() (%zu@%s)", dict->creation_function, dict->creation_line, dict->creation_file);
+static inline void item_linked_list_remove(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    ll_recursive_lock(dict, DICTIONARY_LOCK_WRITE);
+
+    DOUBLE_LINKED_LIST_REMOVE_UNSAFE(dict->items.list, item, prev, next);
 
-    if(nv->next) nv->next->prev = nv->prev;
-    if(nv->prev) nv->prev->next = nv->next;
-    if(dict->first_item == nv) dict->first_item = nv->next;
-    if(dict->last_item == nv) dict->last_item = nv->prev;
+#ifdef NETDATA_INTERNAL_CHECKS
+    item->ll_remover_pid = gettid();
+#endif
+
+    garbage_collect_pending_deletes(dict);
+    ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
 }
 
 // ----------------------------------------------------------------------------
-// NAME_VALUE methods
+// ITEM initialization and updates
 
-static inline size_t namevalue_set_name(DICTIONARY *dict, NAME_VALUE *nv, const char *name, size_t name_len) {
-    if(likely(dict->flags & DICTIONARY_FLAG_NAME_LINK_DONT_CLONE)) {
-        nv->caller_name = (char *)name;
-        return 0;
+static inline size_t item_set_name(DICTIONARY *dict, DICTIONARY_ITEM *item, const char *name, size_t name_len) {
+    if(likely(dict->options & DICT_OPTION_NAME_LINK_DONT_CLONE)) {
+        item->caller_name = (char *)name;
+        item->key_len = name_len;
+    }
+    else {
+        item->string_name = string_strdupz(name);
+        item->key_len = string_strlen(item->string_name) + 1;
+        item->options |= ITEM_OPTION_ALLOCATED_NAME;
     }
 
-    nv->string_name = string_strdupz(name);
-    nv->flags |= NAME_VALUE_FLAG_NAME_IS_ALLOCATED;
-    return name_len;
+    return item->key_len;
 }
 
-static inline size_t namevalue_free_name(DICTIONARY *dict, NAME_VALUE *nv) {
-    if(unlikely(!(dict->flags & DICTIONARY_FLAG_NAME_LINK_DONT_CLONE)))
-        string_freez(nv->string_name);
+static inline size_t item_free_name(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    if(likely(!(dict->options & DICT_OPTION_NAME_LINK_DONT_CLONE)))
+        string_freez(item->string_name);
 
-    return 0;
+    return item->key_len;
 }
 
-static inline const char *namevalue_get_name(NAME_VALUE *nv) {
-    if(nv->flags & NAME_VALUE_FLAG_NAME_IS_ALLOCATED)
-        return string2str(nv->string_name);
+static inline const char *item_get_name(const DICTIONARY_ITEM *item) {
+    if(item->options & ITEM_OPTION_ALLOCATED_NAME)
+        return string2str(item->string_name);
     else
-        return nv->caller_name;
+        return item->caller_name;
 }
 
-static NAME_VALUE *namevalue_create_unsafe(DICTIONARY *dict, const char *name, size_t name_len, void *value, size_t value_len) {
-    debug(D_DICTIONARY, "Creating name value entry for name '%s'.", name);
+static inline size_t item_get_name_len(const DICTIONARY_ITEM *item) {
+    if(item->options & ITEM_OPTION_ALLOCATED_NAME)
+        return string_strlen(item->string_name);
+    else
+        return strlen(item->caller_name);
+}
 
-    size_t size = sizeof(NAME_VALUE);
-    NAME_VALUE *nv = mallocz(size);
-    size_t allocated = size;
+static DICTIONARY_ITEM *dict_item_create(DICTIONARY *dict __maybe_unused, size_t *allocated_bytes, DICTIONARY_ITEM *master_item) {
+    DICTIONARY_ITEM *item;
+
+    size_t size = sizeof(DICTIONARY_ITEM);
+    item = callocz(1, size);
 
 #ifdef NETDATA_INTERNAL_CHECKS
-    nv->dict = dict;
+    item->creator_pid = gettid();
 #endif
 
-    nv->refcount = 0;
-    nv->flags = NAME_VALUE_FLAG_NONE;
-    nv->value_len = value_len;
+    item->refcount = 1;
+    item->flags = ITEM_FLAG_BEING_CREATED;
+
+    *allocated_bytes += size;
 
-    allocated += namevalue_set_name(dict, nv, name, name_len);
+    if(master_item) {
+        item->shared = master_item->shared;
 
-    if(likely(dict->flags & DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE))
-        nv->value = value;
+        if(unlikely(__atomic_add_fetch(&item->shared->links, 1, __ATOMIC_SEQ_CST) <= 1))
+            fatal("DICTIONARY: attempted to link to a shared item structure that had zero references");
+    }
     else {
-        if(likely(value_len)) {
-            if (value) {
-                // a value has been supplied
-                // copy it
-                nv->value = mallocz(value_len);
-                memcpy(nv->value, value, value_len);
-            }
-            else {
-                // no value has been supplied
-                // allocate a clear memory block
-                nv->value = callocz(1, value_len);
-            }
+        size = sizeof(DICTIONARY_ITEM_SHARED);
+        item->shared = callocz(1, size);
+        item->shared->links = 1;
+        *allocated_bytes += size;
+    }
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    item->dict = dict;
+#endif
+    return item;
+}
+
+static void *dict_item_value_create(void *value, size_t value_len) {
+    void *ptr = NULL;
+
+    if(likely(value_len)) {
+        if (likely(value)) {
+            // a value has been supplied
+            // copy it
+            ptr =  mallocz(value_len);
+            memcpy(ptr, value, value_len);
         }
         else {
-            // the caller wants an item without any value
-            nv->value = NULL;
+            // no value has been supplied
+            // allocate a clear memory block
+            ptr = callocz(1, value_len);
         }
+    }
+    // else
+    // the caller wants an item without any value
+
+    return ptr;
+}
+
+static DICTIONARY_ITEM *dict_item_create_with_hooks(DICTIONARY *dict, const char *name, size_t name_len, void *value, size_t value_len, void *constructor_data, DICTIONARY_ITEM *master_item) {
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(unlikely(name_len > KEY_LEN_MAX))
+        fatal("DICTIONARY: tried to index a key of size %zu, but the maximum acceptable is %zu", name_len, (size_t)KEY_LEN_MAX);
+
+    if(unlikely(value_len > VALUE_LEN_MAX))
+        fatal("DICTIONARY: tried to add an item of size %zu, but the maximum acceptable is %zu", value_len, (size_t)VALUE_LEN_MAX);
+#endif
 
-        allocated += value_len;
+    size_t item_size = 0, key_size = 0, value_size = 0;
+
+    DICTIONARY_ITEM *item = dict_item_create(dict, &item_size, master_item);
+    key_size += item_set_name(dict, item, name, name_len);
+
+    if(unlikely(is_view_dictionary(dict))) {
+        // we are on a view dictionary
+        // do not touch the value
+        ;
+
+#ifdef NETDATA_INTERNAL_CHECKS
+        if(unlikely(!master_item))
+            fatal("DICTIONARY: cannot add an item to a view without a master item.");
+#endif
     }
+    else {
+        // we are on the master dictionary
 
-    DICTIONARY_STATS_ENTRIES_PLUS1(dict, allocated);
+        if(unlikely(dict->options & DICT_OPTION_VALUE_LINK_DONT_CLONE))
+            item->shared->value = value;
+        else
+            item->shared->value = dict_item_value_create(value, value_len);
+
+        item->shared->value_len = value_len;
+        value_size += value_len;
+
+        dictionary_execute_insert_callback(dict, item, constructor_data);
+    }
 
-    if(dict->ins_callback)
-        dict->ins_callback(namevalue_get_name(nv), nv->value, dict->ins_callback_data);
+    DICTIONARY_ENTRIES_PLUS1(dict);
+    DICTIONARY_STATS_PLUS_MEMORY(dict, key_size, item_size, value_size);
 
-    return nv;
+    return item;
 }
 
-static void namevalue_reset_unsafe(DICTIONARY *dict, NAME_VALUE *nv, void *value, size_t value_len) {
-    debug(D_DICTIONARY, "Dictionary entry with name '%s' found. Changing its value.", namevalue_get_name(nv));
+static void dict_item_reset_value_with_hooks(DICTIONARY *dict, DICTIONARY_ITEM *item, void *value, size_t value_len, void *constructor_data) {
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: %s() should never be called on views.", __FUNCTION__ );
+
+    debug(D_DICTIONARY, "Dictionary entry with name '%s' found. Changing its value.", item_get_name(item));
+
+    DICTIONARY_VALUE_RESETS_PLUS1(dict);
 
-    DICTIONARY_STATS_VALUE_RESETS_PLUS1(dict, nv->value_len, value_len);
+    if(item->shared->value_len != value_len) {
+        DICTIONARY_STATS_PLUS_MEMORY(dict, 0, 0, value_len);
+        DICTIONARY_STATS_MINUS_MEMORY(dict, 0, 0, item->shared->value_len);
+    }
 
-    if(dict->del_callback)
-        dict->del_callback(namevalue_get_name(nv), nv->value, dict->del_callback_data);
+    dictionary_execute_delete_callback(dict, item);
 
-    if(likely(dict->flags & DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE)) {
-        debug(D_DICTIONARY, "Dictionary: linking value to '%s'", namevalue_get_name(nv));
-        nv->value = value;
-        nv->value_len = value_len;
+    if(likely(dict->options & DICT_OPTION_VALUE_LINK_DONT_CLONE)) {
+        debug(D_DICTIONARY, "Dictionary: linking value to '%s'", item_get_name(item));
+        item->shared->value = value;
+        item->shared->value_len = value_len;
     }
     else {
-        debug(D_DICTIONARY, "Dictionary: cloning value to '%s'", namevalue_get_name(nv));
+        debug(D_DICTIONARY, "Dictionary: cloning value to '%s'", item_get_name(item));
 
-        void *oldvalue = nv->value;
-        void *newvalue = NULL;
+        void *old_value = item->shared->value;
+        void *new_value = NULL;
         if(value_len) {
-            newvalue = mallocz(value_len);
-            if(value) memcpy(newvalue, value, value_len);
-            else memset(newvalue, 0, value_len);
+            new_value = mallocz(value_len);
+            if(value) memcpy(new_value, value, value_len);
+            else memset(new_value, 0, value_len);
         }
-        nv->value = newvalue;
-        nv->value_len = value_len;
+        item->shared->value = new_value;
+        item->shared->value_len = value_len;
 
-        debug(D_DICTIONARY, "Dictionary: freeing old value of '%s'", namevalue_get_name(nv));
-        freez(oldvalue);
+        debug(D_DICTIONARY, "Dictionary: freeing old value of '%s'", item_get_name(item));
+        freez(old_value);
     }
 
-    if(dict->ins_callback)
-        dict->ins_callback(namevalue_get_name(nv), nv->value, dict->ins_callback_data);
+    dictionary_execute_insert_callback(dict, item, constructor_data);
 }
 
-static size_t namevalue_destroy_unsafe(DICTIONARY *dict, NAME_VALUE *nv) {
-    debug(D_DICTIONARY, "Destroying name value entry for name '%s'.", namevalue_get_name(nv));
+static size_t dict_item_free_with_hooks(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    debug(D_DICTIONARY, "Destroying name value entry for name '%s'.", item_get_name(item));
 
-    if(dict->del_callback)
-        dict->del_callback(namevalue_get_name(nv), nv->value, dict->del_callback_data);
+    if(!item_flag_check(item, ITEM_FLAG_DELETED))
+        DICTIONARY_ENTRIES_MINUS1(dict);
 
-    size_t freed = 0;
+    size_t item_size = 0, key_size = 0, value_size = 0;
 
-    if(unlikely(!(dict->flags & DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE))) {
-        debug(D_DICTIONARY, "Dictionary freeing value of '%s'", namevalue_get_name(nv));
-        freez(nv->value);
-        freed += nv->value_len;
-    }
+    key_size += item->key_len;
+    if(unlikely(!(dict->options & DICT_OPTION_NAME_LINK_DONT_CLONE)))
+        item_free_name(dict, item);
 
-    if(unlikely(!(dict->flags & DICTIONARY_FLAG_NAME_LINK_DONT_CLONE))) {
-        debug(D_DICTIONARY, "Dictionary freeing name '%s'", namevalue_get_name(nv));
-        freed += namevalue_free_name(dict, nv);
+    if(item_shared_release_and_check_if_it_can_be_freed(dict, item)) {
+        dictionary_execute_delete_callback(dict, item);
+
+        if(unlikely(!(dict->options & DICT_OPTION_VALUE_LINK_DONT_CLONE))) {
+            debug(D_DICTIONARY, "Dictionary freeing value of '%s'", item_get_name(item));
+            freez(item->shared->value);
+            item->shared->value = NULL;
+        }
+        value_size += item->shared->value_len;
+
+        freez(item->shared);
+        item->shared = NULL;
+        item_size += sizeof(DICTIONARY_ITEM_SHARED);
     }
 
-    freez(nv);
-    freed += sizeof(NAME_VALUE);
+    freez(item);
+    item_size += sizeof(DICTIONARY_ITEM);
 
-    DICTIONARY_STATS_ENTRIES_MINUS_MEMORY(dict, freed);
+    DICTIONARY_STATS_MINUS_MEMORY(dict, key_size, item_size, value_size);
 
-    return freed;
+    // we return the memory we actually freed
+    return item_size + ((dict->options & DICT_OPTION_VALUE_LINK_DONT_CLONE) ? 0 : value_size);
 }
 
-// if a dictionary item can be deleted, return true, otherwise return false
-static bool name_value_can_be_deleted(DICTIONARY *dict, NAME_VALUE *nv) {
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DEFER_ALL_DELETIONS))
-        return false;
+// ----------------------------------------------------------------------------
+// item operations
 
-    if(unlikely(DICTIONARY_NAME_VALUE_REFCOUNT_GET(nv) > 0))
-        return false;
+static void dict_item_shared_set_deleted(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    if(is_master_dictionary(dict)) {
+        item_shared_flag_set(item, ITEM_FLAG_DELETED);
 
-    return true;
+        if(dict->hooks)
+            __atomic_store_n(&dict->hooks->last_master_deletion_us, now_realtime_usec(), __ATOMIC_SEQ_CST);
+    }
 }
 
-// ----------------------------------------------------------------------------
-// API - dictionary management
-#ifdef NETDATA_INTERNAL_CHECKS
-DICTIONARY *dictionary_create_advanced_with_trace(DICTIONARY_FLAGS flags, size_t scratchpad_size, const char *function, size_t line, const char *file) {
-#else
-DICTIONARY *dictionary_create_advanced(DICTIONARY_FLAGS flags, size_t scratchpad_size) {
-#endif
-    debug(D_DICTIONARY, "Creating dictionary.");
+// returns true if we set the deleted flag on this item
+static bool dict_item_set_deleted(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    ITEM_FLAGS expected, desired;
 
-    if(unlikely(flags & DICTIONARY_FLAGS_RESERVED))
-        flags &= ~DICTIONARY_FLAGS_RESERVED;
+    do {
+        expected = __atomic_load_n(&item->flags, __ATOMIC_SEQ_CST);
 
-    DICTIONARY *dict = callocz(1, sizeof(DICTIONARY) + scratchpad_size);
-    size_t allocated = sizeof(DICTIONARY) + scratchpad_size;
+        if (expected & ITEM_FLAG_DELETED)
+            return false;
 
-    dict->scratchpad_size = scratchpad_size;
-    dict->flags = flags;
-    dict->first_item = dict->last_item = NULL;
+        desired = expected | ITEM_FLAG_DELETED;
 
-    allocated += dictionary_lock_init(dict);
-    allocated += reference_counter_init(dict);
-    dict->memory = (long)allocated;
+    } while(!__atomic_compare_exchange_n(&item->flags, &expected, desired,
+                                         false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST));
 
-    hashtable_init_unsafe(dict);
+    DICTIONARY_ENTRIES_MINUS1(dict);
+    return true;
+}
 
-#ifdef NETDATA_INTERNAL_CHECKS
-    dict->creation_function = function;
-    dict->creation_file = file;
-    dict->creation_line = line;
-#endif
+static inline void dict_item_free_or_mark_deleted(DICTIONARY *dict, DICTIONARY_ITEM *item) {
+    int rc = item_is_not_referenced_and_can_be_removed_advanced(dict, item);
+    switch(rc) {
+        case RC_ITEM_OK:
+            // the item is ours, refcount set to -100
+            dict_item_shared_set_deleted(dict, item);
+            item_linked_list_remove(dict, item);
+            dict_item_free_with_hooks(dict, item);
+            break;
 
-    return (DICTIONARY *)dict;
-}
+        case RC_ITEM_IS_REFERENCED:
+        case RC_ITEM_IS_CURRENTLY_BEING_CREATED:
+            // the item is currently referenced by others
+            dict_item_shared_set_deleted(dict, item);
+            dict_item_set_deleted(dict, item);
+            // after this point do not touch the item
+            break;
 
-void *dictionary_scratchpad(DICTIONARY *dict) {
-    return &dict->scratchpad;
-}
+        case RC_ITEM_IS_CURRENTLY_BEING_DELETED:
+            // an item that is currently being deleted by someone else - don't touch it
+            break;
 
-size_t dictionary_destroy(DICTIONARY *dict) {
-    if(!dict) return 0;
+        default:
+            internal_error(true, "Hey dev! You forgot to add the new condition here!");
+            break;
+    }
+}
 
-    NAME_VALUE *nv;
+// this is used by traversal functions to remove the current item
+// if it is deleted and it has zero references. This will eliminate
+// the need for the garbage collector to kick-in later.
+// Most deletions happen during traversal, so this is a nice hack
+// to speed up everything!
+static inline void dict_item_release_and_check_if_it_is_deleted_and_can_be_removed_under_this_lock_mode(DICTIONARY *dict, DICTIONARY_ITEM *item, char rw) {
+    if(rw == DICTIONARY_LOCK_WRITE) {
+        bool should_be_deleted = item_flag_check(item, ITEM_FLAG_DELETED);
 
-    debug(D_DICTIONARY, "Destroying dictionary.");
+        item_release(dict, item);
 
-    long referenced_items = 0;
-    size_t retries = 0;
-    do {
-        referenced_items = __atomic_load_n(&dict->referenced_items, __ATOMIC_SEQ_CST);
-        if (referenced_items) {
-            dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
-
-            // there are referenced items
-            // delete all items individually, so that only the referenced will remain
-            NAME_VALUE *nv_next;
-            for (nv = dict->first_item; nv; nv = nv_next) {
-                nv_next = nv->next;
-                size_t refcount = DICTIONARY_NAME_VALUE_REFCOUNT_GET(nv);
-                if (!refcount && !(nv->flags & NAME_VALUE_FLAG_DELETED))
-                    dictionary_del_unsafe(dict, namevalue_get_name(nv));
-            }
+        if(should_be_deleted && item_is_not_referenced_and_can_be_removed(dict, item)) {
+            // this has to be before removing from the linked list,
+            // otherwise the garbage collector will also kick in!
+            DICTIONARY_PENDING_DELETES_MINUS1(dict);
 
-            internal_error(
-                retries == 0,
-                "DICTIONARY: waiting (try %zu) for destruction of dictionary created from %s() %zu@%s, because it has %ld referenced items in it (%ld total).",
-                retries + 1,
-                dict->creation_function,
-                dict->creation_line,
-                dict->creation_file,
-                referenced_items,
-                dict->entries);
-
-            dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
-            sleep_usec(10000);
+            item_linked_list_remove(dict, item);
+            dict_item_free_with_hooks(dict, item);
         }
-    } while(referenced_items > 0 && ++retries < 10);
-
-    if(referenced_items) {
-        dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
+    }
+    else {
+        // we can't do anything under this mode
+        item_release(dict, item);
+    }
+}
 
-        dict->flags |= DICTIONARY_FLAG_DESTROYED;
+static bool dict_item_del(DICTIONARY *dict, const char *name, ssize_t name_len) {
+    if(unlikely(!name || !*name)) {
         internal_error(
             true,
-            "DICTIONARY: delaying destruction of dictionary created from %s() %zu@%s after %zu retries, because it has %ld referenced items in it (%ld total).",
+            "DICTIONARY: attempted to %s() without a name on a dictionary created from %s() %zu@%s.",
+            __FUNCTION__,
             dict->creation_function,
             dict->creation_line,
-            dict->creation_file,
-            retries,
-            referenced_items,
-            dict->entries);
+            dict->creation_file);
+        return false;
+    }
 
-        dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
-        return 0;
+    if(unlikely(is_dictionary_destroyed(dict))) {
+        internal_error(true, "DICTIONARY: attempted to dictionary_del() on a destroyed dictionary");
+        return false;
     }
 
-    dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
+    if(name_len == -1)
+        name_len = (ssize_t)strlen(name) + 1; // we need the terminating null too
 
-    size_t freed = 0;
-    nv = dict->first_item;
-    while (nv) {
-        // cache nv->next
-        // because we are going to free nv
-        NAME_VALUE *nv_next = nv->next;
-        freed += namevalue_destroy_unsafe(dict, nv);
-        nv = nv_next;
-        // to speed up destruction, we don't
-        // unlink nv from the linked-list here
-    }
+    debug(D_DICTIONARY, "DEL dictionary entry with name '%s'.", name);
 
-    dict->first_item = NULL;
-    dict->last_item = NULL;
+    // Unfortunately, the JudyHSDel() does not return the value of the
+    // item that was deleted, so we have to find it before we delete it,
+    // since we need to release our structures too.
 
-    // destroy the dictionary
-    freed += hashtable_destroy_unsafe(dict);
+    dictionary_index_lock_wrlock(dict);
 
-    dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
-    freed += dictionary_lock_free(dict);
-    freed += reference_counter_free(dict);
-    freed += sizeof(DICTIONARY) + dict->scratchpad_size;
-    freez(dict);
+    int ret;
+    DICTIONARY_ITEM *item = hashtable_get_unsafe(dict, name, name_len);
+    if(unlikely(!item)) {
+        dictionary_index_wrlock_unlock(dict);
+        ret = false;
+    }
+    else {
+        if(hashtable_delete_unsafe(dict, name, name_len, item) == 0)
+            error("DICTIONARY: INTERNAL ERROR: tried to delete item with name '%s', name_len %zd that is not in the index", name, name_len - 1);
+        else
+            pointer_del(dict, item);
 
-    return freed;
-}
+        dictionary_index_wrlock_unlock(dict);
 
-// ----------------------------------------------------------------------------
-// helpers
+        dict_item_free_or_mark_deleted(dict, item);
+        ret = true;
+    }
 
-static NAME_VALUE *dictionary_set_name_value_unsafe(DICTIONARY *dict, const char *name, void *value, size_t value_len) {
-    if(unlikely(!name)) {
-        internal_error(true, "DICTIONARY: attempted to dictionary_set() a dictionary item without a name");
+    return ret;
+}
+
+static DICTIONARY_ITEM *dict_item_add_or_reset_value_and_acquire(DICTIONARY *dict, const char *name, ssize_t name_len, void *value, size_t value_len, void *constructor_data, DICTIONARY_ITEM *master_item) {
+    if(unlikely(!name || !*name)) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to %s() without a name on a dictionary created from %s() %zu@%s.",
+            __FUNCTION__,
+            dict->creation_function,
+            dict->creation_line,
+            dict->creation_file);
         return NULL;
     }
 
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_set() on a destroyed dictionary");
         return NULL;
     }
 
-    internal_error(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS), "DICTIONARY: inserting dictionary item '%s' without exclusive access to dictionary", name);
-
-    size_t name_len = strlen(name) + 1; // we need the terminating null too
+    if(name_len == -1)
+        name_len = (ssize_t)strlen(name) + 1; // we need the terminating null too
 
     debug(D_DICTIONARY, "SET dictionary entry with name '%s'.", name);
 
@@ -979,264 +1581,618 @@ static NAME_VALUE *dictionary_set_name_value_unsafe(DICTIONARY *dict, const char
     // But the caller has the option to do this on his/her own.
     // So, let's do the fastest here and let the caller decide the flow of calls.
 
-    NAME_VALUE *nv, **pnv = hashtable_insert_unsafe(dict, name, name_len);
-    if(likely(*pnv == 0)) {
-        // a new item added to the index
-        nv = *pnv = namevalue_create_unsafe(dict, name, name_len, value, value_len);
-        hashtable_inserted_name_value_unsafe(dict, nv);
-        linkedlist_namevalue_link_unsafe(dict, nv);
-        nv->flags |= NAME_VALUE_FLAG_NEW_OR_UPDATED;
-    }
-    else {
-        // the item is already in the index
-        // so, either we will return the old one
-        // or overwrite the value, depending on dictionary flags
+    dictionary_index_lock_wrlock(dict);
 
-        nv = *pnv;
+    bool added_or_updated = false;
+    size_t spins = 0;
+    DICTIONARY_ITEM *item = NULL;
+    do {
+        DICTIONARY_ITEM **item_pptr = (DICTIONARY_ITEM **)hashtable_insert_unsafe(dict, name, name_len);
+        if (likely(*item_pptr == NULL)) {
+            // a new item added to the index
 
-        if(!(dict->flags & DICTIONARY_FLAG_DONT_OVERWRITE_VALUE)) {
-            namevalue_reset_unsafe(dict, nv, value, value_len);
-            nv->flags |= NAME_VALUE_FLAG_NEW_OR_UPDATED;
-        }
+            // create the dictionary item
+            item = *item_pptr =
+                dict_item_create_with_hooks(dict, name, name_len, value, value_len, constructor_data, master_item);
 
-        else if(dict->conflict_callback) {
-            dict->conflict_callback(namevalue_get_name(nv), nv->value, value, dict->conflict_callback_data);
-            nv->flags |= NAME_VALUE_FLAG_NEW_OR_UPDATED;
-        }
+            pointer_add(dict, item);
+
+            // call the hashtable react
+            hashtable_inserted_item_unsafe(dict, item);
+
+            // unlock the index lock, before we add it to the linked list
+            // DONT DO IT THE OTHER WAY AROUND - DO NOT CROSS THE LOCKS!
+            dictionary_index_wrlock_unlock(dict);
+
+            item_linked_list_add(dict, item);
 
+            added_or_updated = true;
+        }
         else {
-            // make sure this flag is not set
-            nv->flags &= ~NAME_VALUE_FLAG_NEW_OR_UPDATED;
+            pointer_check(dict, *item_pptr);
+
+            if(item_check_and_acquire_advanced(dict, *item_pptr, true) != RC_ITEM_OK) {
+                spins++;
+                continue;
+            }
+
+            // the item is already in the index
+            // so, either we will return the old one
+            // or overwrite the value, depending on dictionary flags
+
+            // We should not compare the values here!
+            // even if they are the same, we have to do the whole job
+            // so that the callbacks will be called.
+
+            item = *item_pptr;
+
+            if(is_view_dictionary(dict)) {
+                // view dictionary
+                // the item is already there and can be used
+                if(item->shared != master_item->shared)
+                    error("DICTIONARY: changing the master item on a view is not supported. The previous item will remain. To change the key of an item in a view, delete it and add it again.");
+            }
+            else {
+                // master dictionary
+                // the user wants to reset its value
+
+                if (!(dict->options & DICT_OPTION_DONT_OVERWRITE_VALUE)) {
+                    dict_item_reset_value_with_hooks(dict, item, value, value_len, constructor_data);
+                    added_or_updated = true;
+                }
+
+                else if (dictionary_execute_conflict_callback(dict, item, value, constructor_data)) {
+                    dictionary_version_increment(dict);
+                    added_or_updated = true;
+                }
+
+                else {
+                    // conflict callback returned false
+                    // we did really nothing!
+                    ;
+                }
+            }
+
+            dictionary_index_wrlock_unlock(dict);
         }
-    }
+    } while(!item);
+
+
+    if(unlikely(spins > 0 && dict->stats))
+        DICTIONARY_STATS_INSERT_SPINS_PLUS(dict, spins);
 
-    return nv;
+    if(is_master_dictionary(dict) && added_or_updated)
+        dictionary_execute_react_callback(dict, item, constructor_data);
+
+    return item;
 }
 
-static NAME_VALUE *dictionary_get_name_value_unsafe(DICTIONARY *dict, const char *name) {
-    if(unlikely(!name)) {
-        internal_error(true, "attempted to dictionary_get() without a name");
+static DICTIONARY_ITEM *dict_item_find_and_acquire(DICTIONARY *dict, const char *name, ssize_t name_len) {
+    if(unlikely(!name || !*name)) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to %s() without a name on a dictionary created from %s() %zu@%s.",
+            __FUNCTION__,
+            dict->creation_function,
+            dict->creation_line,
+            dict->creation_file);
         return NULL;
     }
 
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_get() on a destroyed dictionary");
         return NULL;
     }
 
-    size_t name_len = strlen(name) + 1; // we need the terminating null too
+    if(name_len == -1)
+        name_len = (ssize_t)strlen(name) + 1; // we need the terminating null too
 
     debug(D_DICTIONARY, "GET dictionary entry with name '%s'.", name);
 
-    NAME_VALUE *nv = hashtable_get_unsafe(dict, name, name_len);
-    if(unlikely(!nv)) {
-        debug(D_DICTIONARY, "Not found dictionary entry with name '%s'.", name);
-        return NULL;
+    dictionary_index_lock_rdlock(dict);
+
+    DICTIONARY_ITEM *item = hashtable_get_unsafe(dict, name, name_len);
+    if(unlikely(item && !item_check_and_acquire(dict, item))) {
+        item = NULL;
+        DICTIONARY_STATS_SEARCH_IGNORES_PLUS1(dict);
     }
 
-    debug(D_DICTIONARY, "Found dictionary entry with name '%s'.", name);
-    return nv;
+    dictionary_index_rdlock_unlock(dict);
+
+    return item;
 }
 
 // ----------------------------------------------------------------------------
-// API - items management
+// delayed destruction of dictionaries
+
+static bool dictionary_free_all_resources(DICTIONARY *dict, size_t *mem, bool force) {
+    if(mem)
+        *mem = 0;
+
+    if(!force && dictionary_referenced_items(dict))
+        return false;
+
+    size_t dict_size = 0, counted_items = 0, item_size = 0, index_size = 0;
+    (void)counted_items;
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    long int entries = dict->entries;
+    long int referenced_items = dict->referenced_items;
+    long int pending_deletion_items = dict->pending_deletion_items;
+    const char *creation_function = dict->creation_function;
+    const char *creation_file = dict->creation_file;
+    size_t creation_line = dict->creation_line;
+#endif
+
+    // destroy the index
+    dictionary_index_lock_wrlock(dict);
+    index_size += hashtable_destroy_unsafe(dict);
+    dictionary_index_wrlock_unlock(dict);
+
+    ll_recursive_lock(dict, DICTIONARY_LOCK_WRITE);
+    DICTIONARY_ITEM *item = dict->items.list;
+    while (item) {
+        // cache item->next
+        // because we are going to free item
+        DICTIONARY_ITEM *item_next = item->next;
 
-void *dictionary_set_unsafe(DICTIONARY *dict, const char *name, void *value, size_t value_len) {
-    NAME_VALUE *nv = dictionary_set_name_value_unsafe(dict, name, value, value_len);
+        item_size += dict_item_free_with_hooks(dict, item);
+        item = item_next;
 
-    if(unlikely(dict->react_callback && nv && (nv->flags & NAME_VALUE_FLAG_NEW_OR_UPDATED))) {
-        // we need to call the react callback with a reference counter on nv
-        reference_counter_acquire(dict, nv);
-        dict->react_callback(namevalue_get_name(nv), nv->value, dict->react_callback_data);
-        reference_counter_release(dict, nv, false);
+        // to speed up destruction, we don't
+        // unlink item from the linked-list here
+
+        counted_items++;
     }
+    dict->items.list = NULL;
+    ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
+
+    dict_size += dictionary_locks_destroy(dict);
+    dict_size += reference_counter_free(dict);
+    dict_size += dictionary_hooks_free(dict);
+    dict_size += sizeof(DICTIONARY);
+    DICTIONARY_STATS_MINUS_MEMORY(dict, 0, sizeof(DICTIONARY), 0);
+
+    freez(dict);
+
+    internal_error(
+        false,
+        "DICTIONARY: Freed dictionary created from %s() %zu@%s, having %ld (counted %zu) entries, %ld referenced, %ld pending deletion, total freed memory: %zu bytes (sizeof(dict) = %zu, sizeof(item) = %zu).",
+        creation_function,
+        creation_line,
+        creation_file,
+        entries, counted_items, referenced_items, pending_deletion_items,
+        dict_size + item_size, sizeof(DICTIONARY), sizeof(DICTIONARY_ITEM) + sizeof(DICTIONARY_ITEM_SHARED));
+
+    if(mem)
+        *mem = dict_size + item_size + index_size;
 
-    return nv ? nv->value : NULL;
+    return true;
 }
 
-void *dictionary_set(DICTIONARY *dict, const char *name, void *value, size_t value_len) {
-    dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
-    NAME_VALUE *nv = dictionary_set_name_value_unsafe(dict, name, value, value_len);
+netdata_mutex_t dictionaries_waiting_to_be_destroyed_mutex = NETDATA_MUTEX_INITIALIZER;
+static DICTIONARY *dictionaries_waiting_to_be_destroyed = NULL;
+
+void dictionary_queue_for_destruction(DICTIONARY *dict) {
+    if(is_dictionary_destroyed(dict))
+        return;
 
-    // we need to get a reference counter for the react callback
-    // before we unlock the dictionary
-    if(unlikely(dict->react_callback && nv && (nv->flags & NAME_VALUE_FLAG_NEW_OR_UPDATED)))
-        reference_counter_acquire(dict, nv);
+    DICTIONARY_STATS_DICT_DESTROY_QUEUED_PLUS1(dict);
+    dict_flag_set(dict, DICT_FLAG_DESTROYED);
 
-    dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
+    netdata_mutex_lock(&dictionaries_waiting_to_be_destroyed_mutex);
 
-    if(unlikely(dict->react_callback && nv && (nv->flags & NAME_VALUE_FLAG_NEW_OR_UPDATED))) {
-        // we got the reference counter we need, above
-        dict->react_callback(namevalue_get_name(nv), nv->value, dict->react_callback_data);
-        reference_counter_release(dict, nv, false);
-    }
+    dict->next = dictionaries_waiting_to_be_destroyed;
+    dictionaries_waiting_to_be_destroyed = dict;
 
-    return nv ? nv->value : NULL;
+    netdata_mutex_unlock(&dictionaries_waiting_to_be_destroyed_mutex);
 }
 
-DICTIONARY_ITEM *dictionary_set_and_acquire_item_unsafe(DICTIONARY *dict, const char *name, void *value, size_t value_len) {
-    NAME_VALUE *nv = dictionary_set_name_value_unsafe(dict, name, value, value_len);
+void cleanup_destroyed_dictionaries(void) {
+    if(!dictionaries_waiting_to_be_destroyed)
+        return;
 
-    if(unlikely(!nv))
-        return NULL;
+    netdata_mutex_lock(&dictionaries_waiting_to_be_destroyed_mutex);
+
+    DICTIONARY *dict, *last = NULL, *next = NULL;
+    for(dict = dictionaries_waiting_to_be_destroyed; dict ; dict = next) {
+        next = dict->next;
 
-    reference_counter_acquire(dict, nv);
+#ifdef NETDATA_INTERNAL_CHECKS
+        size_t line = dict->creation_line;
+        const char *file = dict->creation_file;
+        const char *function = dict->creation_function;
+#endif
 
-    if(unlikely(dict->react_callback && (nv->flags & NAME_VALUE_FLAG_NEW_OR_UPDATED))) {
-        dict->react_callback(namevalue_get_name(nv), nv->value, dict->react_callback_data);
+        DICTIONARY_STATS_DICT_DESTROY_QUEUED_MINUS1(dict);
+        if(dictionary_free_all_resources(dict, NULL, false)) {
+
+            internal_error(
+                true,
+                "DICTIONARY: freed dictionary with delayed destruction, created from %s() %zu@%s.",
+                function, line, file);
+
+            if(last) last->next = next;
+            else dictionaries_waiting_to_be_destroyed = next;
+        }
+        else {
+            DICTIONARY_STATS_DICT_DESTROY_QUEUED_PLUS1(dict);
+            last = dict;
+        }
     }
 
-    return (DICTIONARY_ITEM *)nv;
+    netdata_mutex_unlock(&dictionaries_waiting_to_be_destroyed_mutex);
 }
 
-DICTIONARY_ITEM *dictionary_set_and_acquire_item(DICTIONARY *dict, const char *name, void *value, size_t value_len) {
-    dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
-    NAME_VALUE *nv = dictionary_set_name_value_unsafe(dict, name, value, value_len);
+// ----------------------------------------------------------------------------
+// API internal checks
 
-    // we need to get the reference counter before we unlock
-    if(nv) reference_counter_acquire(dict, nv);
+#ifdef NETDATA_INTERNAL_CHECKS
+#define api_internal_check(dict, item, allow_null_dict, allow_null_item) api_internal_check_with_trace(dict, item, __FUNCTION__, allow_null_dict, allow_null_item)
+static inline void api_internal_check_with_trace(DICTIONARY *dict, DICTIONARY_ITEM *item, const char *function, bool allow_null_dict, bool allow_null_item) {
+    if(!allow_null_dict && !dict) {
+        internal_error(
+            item,
+            "DICTIONARY: attempted to %s() with a NULL dictionary, passing an item created from %s() %zu@%s.",
+            function,
+            item->dict->creation_function,
+            item->dict->creation_line,
+            item->dict->creation_file);
+        fatal("DICTIONARY: attempted to %s() but dict is NULL", function);
+    }
 
-    dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
+    if(!allow_null_item && !item) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to %s() without an item on a dictionary created from %s() %zu@%s.",
+            function,
+            dict?dict->creation_function:"unknown",
+            dict?dict->creation_line:0,
+            dict?dict->creation_file:"unknown");
+        fatal("DICTIONARY: attempted to %s() but item is NULL", function);
+    }
 
-    if(unlikely(dict->react_callback && nv && (nv->flags & NAME_VALUE_FLAG_NEW_OR_UPDATED))) {
-        // we already have a reference counter, for the caller, no need for another one
-        dict->react_callback(namevalue_get_name(nv), nv->value, dict->react_callback_data);
+    if(dict && item && dict != item->dict) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to %s() an item on a dictionary created from %s() %zu@%s, but the item belongs to the dictionary created from %s() %zu@%s.",
+            function,
+            dict->creation_function,
+            dict->creation_line,
+            dict->creation_file,
+            item->dict->creation_function,
+            item->dict->creation_line,
+            item->dict->creation_file
+        );
+        fatal("DICTIONARY: %s(): item does not belong to this dictionary.", function);
     }
 
-    return (DICTIONARY_ITEM *)nv;
+    if(item) {
+        REFCOUNT refcount = DICTIONARY_ITEM_REFCOUNT_GET(dict, item);
+        if (unlikely(refcount <= 0)) {
+            internal_error(
+                true,
+                "DICTIONARY: attempted to %s() of an item with reference counter = %d on a dictionary created from %s() %zu@%s",
+                function,
+                refcount,
+                item->dict->creation_function,
+                item->dict->creation_line,
+                item->dict->creation_file);
+            fatal("DICTIONARY: attempted to %s but item is having refcount = %d", function, refcount);
+        }
+    }
 }
+#else
+#define api_internal_check(dict, item, allow_null_dict, allow_null_item) debug_dummy()
+#endif
 
-void *dictionary_get_unsafe(DICTIONARY *dict, const char *name) {
-    NAME_VALUE *nv = dictionary_get_name_value_unsafe(dict, name);
+#define api_is_name_good(dict, name, name_len) api_is_name_good_with_trace(dict, name, name_len, __FUNCTION__)
+static bool api_is_name_good_with_trace(DICTIONARY *dict __maybe_unused, const char *name, ssize_t name_len __maybe_unused, const char *function __maybe_unused) {
+    if(unlikely(!name)) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to %s() with name = NULL on a dictionary created from %s() %zu@%s.",
+            function,
+            dict?dict->creation_function:"unknown",
+            dict?dict->creation_line:0,
+            dict?dict->creation_file:"unknown");
+        return false;
+    }
 
-    if(unlikely(!nv))
-        return NULL;
+    if(unlikely(!*name)) {
+        internal_error(
+            true,
+            "DICTIONARY: attempted to %s() with empty name on a dictionary created from %s() %zu@%s.",
+            function,
+            dict?dict->creation_function:"unknown",
+            dict?dict->creation_line:0,
+            dict?dict->creation_file:"unknown");
+        return false;
+    }
 
-    return nv->value;
-}
+    internal_error(
+        name_len > 0 && name_len != (ssize_t)(strlen(name) + 1),
+        "DICTIONARY: attempted to %s() with a name of '%s', having length of %zu (incl. '\\0'), but the supplied name_len = %ld, on a dictionary created from %s() %zu@%s.",
+        function,
+        name,
+        strlen(name) + 1,
+        (long int) name_len,
+        dict?dict->creation_function:"unknown",
+        dict?dict->creation_line:0,
+        dict?dict->creation_file:"unknown");
+
+    internal_error(
+        name_len <= 0 && name_len != -1,
+        "DICTIONARY: attempted to %s() with a name of '%s', having length of %zu (incl. '\\0'), but the supplied name_len = %ld, on a dictionary created from %s() %zu@%s.",
+        function,
+        name,
+        strlen(name) + 1,
+        (long int) name_len,
+        dict?dict->creation_function:"unknown",
+        dict?dict->creation_line:0,
+        dict?dict->creation_file:"unknown");
 
-void *dictionary_get(DICTIONARY *dict, const char *name) {
-    dictionary_lock(dict, DICTIONARY_LOCK_READ);
-    void *ret = dictionary_get_unsafe(dict, name);
-    dictionary_unlock(dict, DICTIONARY_LOCK_READ);
-    return ret;
+    return true;
 }
 
-DICTIONARY_ITEM *dictionary_get_and_acquire_item_unsafe(DICTIONARY *dict, const char *name) {
-    NAME_VALUE *nv = dictionary_get_name_value_unsafe(dict, name);
+// ----------------------------------------------------------------------------
+// API - dictionary management
 
-    if(unlikely(!nv))
-        return NULL;
+static DICTIONARY *dictionary_create_internal(DICT_OPTIONS options, struct dictionary_stats *stats) {
+    cleanup_destroyed_dictionaries();
 
-    reference_counter_acquire(dict, nv);
-    return (DICTIONARY_ITEM *)nv;
-}
+    DICTIONARY *dict = callocz(1, sizeof(DICTIONARY));
+    dict->options = options;
+    dict->stats = stats;
 
-DICTIONARY_ITEM *dictionary_get_and_acquire_item(DICTIONARY *dict, const char *name) {
-    dictionary_lock(dict, DICTIONARY_LOCK_READ);
-    void *ret = dictionary_get_and_acquire_item_unsafe(dict, name);
-    dictionary_unlock(dict, DICTIONARY_LOCK_READ);
-    return ret;
-}
+    size_t dict_size = 0;
+    dict_size += sizeof(DICTIONARY);
+    dict_size += dictionary_locks_init(dict);
+    dict_size += reference_counter_init(dict);
+    dict_size += hashtable_init_unsafe(dict);
 
-DICTIONARY_ITEM *dictionary_acquired_item_dup(DICTIONARY_ITEM *item) {
-    if(unlikely(!item)) return NULL;
-    reference_counter_increase((NAME_VALUE *)item);
-    return item;
-}
+    pointer_index_init(dict);
 
-const char *dictionary_acquired_item_name(DICTIONARY_ITEM *item) {
-    if(unlikely(!item)) return NULL;
-    return namevalue_get_name((NAME_VALUE *)item);
-}
+    DICTIONARY_STATS_PLUS_MEMORY(dict, 0, dict_size, 0);
 
-void *dictionary_acquired_item_value(DICTIONARY_ITEM *item) {
-    if(unlikely(!item)) return NULL;
-    return ((NAME_VALUE *)item)->value;
+    return dict;
 }
 
-void dictionary_acquired_item_release_unsafe(DICTIONARY *dict, DICTIONARY_ITEM *item) {
-    if(unlikely(!item)) return;
+#ifdef NETDATA_INTERNAL_CHECKS
+DICTIONARY *dictionary_create_advanced_with_trace(DICT_OPTIONS options, struct dictionary_stats *stats, const char *function, size_t line, const char *file) {
+#else
+DICTIONARY *dictionary_create_advanced(DICT_OPTIONS options, struct dictionary_stats *stats) {
+#endif
+
+    DICTIONARY *dict = dictionary_create_internal(options, stats?stats:&dictionary_stats_category_other);
 
 #ifdef NETDATA_INTERNAL_CHECKS
-    if(((NAME_VALUE *)item)->dict != dict)
-        fatal("DICTIONARY: %s(): name_value item with name '%s' does not belong to this dictionary", __FUNCTION__, namevalue_get_name((NAME_VALUE *)item));
+    dict->creation_function = function;
+    dict->creation_file = file;
+    dict->creation_line = line;
 #endif
 
-    reference_counter_release(dict, (NAME_VALUE *)item, false);
+    DICTIONARY_STATS_DICT_CREATIONS_PLUS1(dict);
+    return dict;
 }
 
-void dictionary_acquired_item_release(DICTIONARY *dict, DICTIONARY_ITEM *item) {
-    if(unlikely(!item)) return;
+#ifdef NETDATA_INTERNAL_CHECKS
+DICTIONARY *dictionary_create_view_with_trace(DICTIONARY *master, const char *function, size_t line, const char *file) {
+#else
+DICTIONARY *dictionary_create_view(DICTIONARY *master) {
+#endif
+
+    DICTIONARY *dict = dictionary_create_internal(master->options, master->stats);
+    dict->master = master;
+
+    dictionary_hooks_allocate(master);
+
+    if(unlikely(__atomic_load_n(&master->hooks->links, __ATOMIC_SEQ_CST)) < 1)
+        fatal("DICTIONARY: attempted to create a view that has %d links", master->hooks->links);
+
+    dict->hooks = master->hooks;
+    __atomic_add_fetch(&master->hooks->links, 1, __ATOMIC_SEQ_CST);
 
 #ifdef NETDATA_INTERNAL_CHECKS
-    if(((NAME_VALUE *)item)->dict != dict)
-        fatal("DICTIONARY: %s(): name_value item with name '%s' does not belong to this dictionary", __FUNCTION__, namevalue_get_name((NAME_VALUE *)item));
+    dict->creation_function = function;
+    dict->creation_file = file;
+    dict->creation_line = line;
 #endif
 
-    // no need to get a lock here
-    // we pass the last parameter to reference_counter_release() as true
-    // so that the release may get a write-lock if required to clean up
+    DICTIONARY_STATS_DICT_CREATIONS_PLUS1(dict);
+    return dict;
+}
 
-    reference_counter_release(dict, (NAME_VALUE *)item, true);
+void dictionary_flush(DICTIONARY *dict) {
+    if(unlikely(!dict))
+        return;
 
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED))
-        dictionary_destroy(dict);
+    void *value;
+    dfe_start_write(dict, value) {
+        dictionary_del_advanced(dict, item_get_name(value_dfe.item), (ssize_t)item_get_name_len(value_dfe.item) + 1);
+    }
+    dfe_done(value);
+
+    DICTIONARY_STATS_DICT_FLUSHES_PLUS1(dict);
 }
 
-int dictionary_del_unsafe(DICTIONARY *dict, const char *name) {
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED)) {
-        internal_error(true, "DICTIONARY: attempted to dictionary_del() on a destroyed dictionary");
-        return -1;
+size_t dictionary_destroy(DICTIONARY *dict) {
+    cleanup_destroyed_dictionaries();
+
+    if(!dict) return 0;
+
+    ll_recursive_lock(dict, DICTIONARY_LOCK_WRITE);
+
+    dict_flag_set(dict, DICT_FLAG_DESTROYED);
+    DICTIONARY_STATS_DICT_DESTRUCTIONS_PLUS1(dict);
+
+    size_t referenced_items = dictionary_referenced_items(dict);
+    if(referenced_items) {
+        dictionary_flush(dict);
+        dictionary_queue_for_destruction(dict);
+
+        internal_error(
+            true,
+            "DICTIONARY: delaying destruction of dictionary created from %s() %zu@%s, because it has %ld referenced items in it (%ld total).",
+            dict->creation_function,
+            dict->creation_line,
+            dict->creation_file,
+            dict->referenced_items,
+            dict->entries);
+
+        ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
+        return 0;
     }
 
-    if(unlikely(!name || !*name)) {
-        internal_error(true, "DICTIONARY: attempted to dictionary_del() without a name");
-        return -1;
+    ll_recursive_unlock(dict, DICTIONARY_LOCK_WRITE);
+
+    size_t freed;
+    dictionary_free_all_resources(dict, &freed, true);
+
+    return freed;
+}
+
+// ----------------------------------------------------------------------------
+// SET an item to the dictionary
+
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_set_and_acquire_item_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, void *value, size_t value_len, void *constructor_data) {
+    if(unlikely(!api_is_name_good(dict, name, name_len)))
+        return NULL;
+
+    api_internal_check(dict, NULL, false, true);
+
+    if(unlikely(is_view_dictionary(dict)))
+        fatal("DICTIONARY: this dictionary is a view, you cannot add items other than the ones from the master dictionary.");
+
+    DICTIONARY_ITEM *item =
+        dict_item_add_or_reset_value_and_acquire(dict, name, name_len, value, value_len, constructor_data, NULL);
+    api_internal_check(dict, item, false, false);
+    return item;
+}
+
+void *dictionary_set_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, void *value, size_t value_len, void *constructor_data) {
+    DICTIONARY_ITEM *item = dictionary_set_and_acquire_item_advanced(dict, name, name_len, value, value_len, constructor_data);
+
+    if(likely(item)) {
+        void *v = item->shared->value;
+        item_release(dict, item);
+        return v;
     }
 
-    internal_error(!(dict->flags & DICTIONARY_FLAG_EXCLUSIVE_ACCESS), "DICTIONARY: INTERNAL ERROR: deleting dictionary item '%s' without exclusive access to dictionary", name);
+    return NULL;
+}
+
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_view_set_and_acquire_item_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, DICTIONARY_ITEM *master_item) {
+    if(unlikely(!api_is_name_good(dict, name, name_len)))
+        return NULL;
 
-    size_t name_len = strlen(name) + 1; // we need the terminating null too
+    api_internal_check(dict, NULL, false, true);
 
-    debug(D_DICTIONARY, "DEL dictionary entry with name '%s'.", name);
+    if(unlikely(is_master_dictionary(dict)))
+        fatal("DICTIONARY: this dictionary is a master, you cannot add items from other dictionaries.");
 
-    // Unfortunately, the JudyHSDel() does not return the value of the
-    // item that was deleted, so we have to find it before we delete it,
-    // since we need to release our structures too.
+    dictionary_acquired_item_dup(dict->master, master_item);
+    DICTIONARY_ITEM *item = dict_item_add_or_reset_value_and_acquire(dict, name, name_len, NULL, 0, NULL, master_item);
+    dictionary_acquired_item_release(dict->master, master_item);
 
-    int ret;
-    NAME_VALUE *nv = hashtable_get_unsafe(dict, name, name_len);
-    if(unlikely(!nv)) {
-        debug(D_DICTIONARY, "Not found dictionary entry with name '%s'.", name);
-        ret = -1;
+    api_internal_check(dict, item, false, false);
+    return item;
+}
+
+void *dictionary_view_set_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, DICTIONARY_ITEM *master_item) {
+    DICTIONARY_ITEM *item = dictionary_view_set_and_acquire_item_advanced(dict, name, name_len, master_item);
+
+    if(likely(item)) {
+        void *v = item->shared->value;
+        item_release(dict, item);
+        return v;
     }
-    else {
-        debug(D_DICTIONARY, "Found dictionary entry with name '%s'.", name);
 
-        if(hashtable_delete_unsafe(dict, name, name_len, nv) == 0)
-            error("DICTIONARY: INTERNAL ERROR: tried to delete item with name '%s' that is not in the index", name);
+    return NULL;
+}
 
-        if(name_value_can_be_deleted(dict, nv)) {
-            linkedlist_namevalue_unlink_unsafe(dict, nv);
-            namevalue_destroy_unsafe(dict, nv);
-        }
-        else
-            nv->flags |= NAME_VALUE_FLAG_DELETED;
+// ----------------------------------------------------------------------------
+// GET an item from the dictionary
 
-        ret = 0;
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_get_and_acquire_item_advanced(DICTIONARY *dict, const char *name, ssize_t name_len) {
+    if(unlikely(!api_is_name_good(dict, name, name_len)))
+        return NULL;
 
-        DICTIONARY_STATS_ENTRIES_MINUS1(dict);
+    api_internal_check(dict, NULL, false, true);
+    DICTIONARY_ITEM *item = dict_item_find_and_acquire(dict, name, name_len);
+    api_internal_check(dict, item, false, true);
+    return item;
+}
+
+void *dictionary_get_advanced(DICTIONARY *dict, const char *name, ssize_t name_len) {
+    DICTIONARY_ITEM *item = dictionary_get_and_acquire_item_advanced(dict, name, name_len);
 
+    if(likely(item)) {
+        void *v = item->shared->value;
+        item_release(dict, item);
+        return v;
     }
-    return ret;
+
+    return NULL;
 }
 
-int dictionary_del(DICTIONARY *dict, const char *name) {
-    dictionary_lock(dict, DICTIONARY_LOCK_WRITE);
-    int ret = dictionary_del_unsafe(dict, name);
-    dictionary_unlock(dict, DICTIONARY_LOCK_WRITE);
-    return ret;
+// ----------------------------------------------------------------------------
+// DUP/REL an item (increase/decrease its reference counter)
+
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_acquired_item_dup(DICTIONARY *dict, DICT_ITEM_CONST DICTIONARY_ITEM *item) {
+    // we allow the item to be NULL here
+    api_internal_check(dict, item, false, true);
+
+    if(likely(item)) {
+        item_acquire(dict, item);
+        api_internal_check(dict, item, false, false);
+    }
+
+    return item;
+}
+
+void dictionary_acquired_item_release(DICTIONARY *dict, DICT_ITEM_CONST DICTIONARY_ITEM *item) {
+    // we allow the item to be NULL here
+    api_internal_check(dict, item, false, true);
+
+    // no need to get a lock here
+    // we pass the last parameter to reference_counter_release() as true
+    // so that the release may get a write-lock if required to clean up
+
+    if(likely(item))
+        item_release(dict, item);
+}
+
+// ----------------------------------------------------------------------------
+// get the name/value of an item
+
+const char *dictionary_acquired_item_name(DICT_ITEM_CONST DICTIONARY_ITEM *item) {
+    return item_get_name(item);
+}
+
+void *dictionary_acquired_item_value(DICT_ITEM_CONST DICTIONARY_ITEM *item) {
+    if(likely(item))
+        return item->shared->value;
+
+    return NULL;
+}
+
+size_t dictionary_acquired_item_references(DICT_ITEM_CONST DICTIONARY_ITEM *item) {
+    if(likely(item))
+        return DICTIONARY_ITEM_REFCOUNT_GET_SOLE(item);
+
+    return 0;
+}
+
+// ----------------------------------------------------------------------------
+// DEL an item
+
+bool dictionary_del_advanced(DICTIONARY *dict, const char *name, ssize_t name_len) {
+    if(unlikely(!api_is_name_good(dict, name, name_len)))
+        return false;
+
+    api_internal_check(dict, NULL, false, true);
+    return dict_item_del(dict, name, name_len);
 }
 
 // ----------------------------------------------------------------------------
@@ -1245,150 +2201,165 @@ int dictionary_del(DICTIONARY *dict, const char *name) {
 void *dictionary_foreach_start_rw(DICTFE *dfe, DICTIONARY *dict, char rw) {
     if(unlikely(!dfe || !dict)) return NULL;
 
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_foreach_start_rw() on a destroyed dictionary");
-        dfe->last_item = NULL;
+        dfe->counter = 0;
+        dfe->item = NULL;
         dfe->name = NULL;
         dfe->value = NULL;
         return NULL;
     }
 
+    dfe->counter = 0;
     dfe->dict = dict;
     dfe->rw = rw;
-    dfe->started_ut = now_realtime_usec();
 
-    dictionary_lock(dict, dfe->rw);
+    ll_recursive_lock(dict, dfe->rw);
 
-    DICTIONARY_STATS_WALKTHROUGHS_PLUS1(dict);
+    DICTIONARY_STATS_TRAVERSALS_PLUS1(dict);
 
     // get the first item from the list
-    NAME_VALUE *nv = dict->first_item;
+    DICTIONARY_ITEM *item = dict->items.list;
 
     // skip all the deleted items
-    while(nv && (nv->flags & NAME_VALUE_FLAG_DELETED))
-        nv = nv->next;
+    while(item && !item_check_and_acquire(dict, item))
+        item = item->next;
 
-    if(likely(nv)) {
-        dfe->last_item = nv;
-        dfe->name = (char *)namevalue_get_name(nv);
-        dfe->value = nv->value;
-        reference_counter_acquire(dict, nv);
+    if(likely(item)) {
+        dfe->item = item;
+        dfe->name = (char *)item_get_name(item);
+        dfe->value = item->shared->value;
     }
     else {
-        dfe->last_item = NULL;
+        dfe->item = NULL;
         dfe->name = NULL;
         dfe->value = NULL;
     }
 
+    if(unlikely(dfe->rw == DICTIONARY_LOCK_REENTRANT))
+        ll_recursive_unlock(dfe->dict, dfe->rw);
+
     return dfe->value;
 }
 
 void *dictionary_foreach_next(DICTFE *dfe) {
     if(unlikely(!dfe || !dfe->dict)) return NULL;
 
-    if(unlikely(dfe->dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dfe->dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_foreach_next() on a destroyed dictionary");
-        dfe->last_item = NULL;
+        dfe->item = NULL;
         dfe->name = NULL;
         dfe->value = NULL;
         return NULL;
     }
 
+    if(unlikely(dfe->rw == DICTIONARY_LOCK_REENTRANT))
+        ll_recursive_lock(dfe->dict, dfe->rw);
+
     // the item we just did
-    NAME_VALUE *nv = (NAME_VALUE *)dfe->last_item;
+    DICTIONARY_ITEM *item = dfe->item;
 
     // get the next item from the list
-    NAME_VALUE *nv_next = (nv) ? nv->next : NULL;
+    DICTIONARY_ITEM *item_next = (item) ? item->next : NULL;
 
-    // skip all the deleted items
-    while(nv_next && (nv_next->flags & NAME_VALUE_FLAG_DELETED))
-        nv_next = nv_next->next;
+    // skip all the deleted items until one that can be acquired is found
+    while(item_next && !item_check_and_acquire(dfe->dict, item_next))
+        item_next = item_next->next;
 
-    // release the old, so that it can possibly be deleted
-    if(likely(nv))
-        reference_counter_release(dfe->dict, nv, false);
+    if(likely(item)) {
+        dict_item_release_and_check_if_it_is_deleted_and_can_be_removed_under_this_lock_mode(dfe->dict, item, dfe->rw);
+        // item_release(dfe->dict, item);
+    }
 
-    if(likely(nv = nv_next)) {
-        dfe->last_item = nv;
-        dfe->name = (char *)namevalue_get_name(nv);
-        dfe->value = nv->value;
-        reference_counter_acquire(dfe->dict, nv);
+    item = item_next;
+    if(likely(item)) {
+        dfe->item = item;
+        dfe->name = (char *)item_get_name(item);
+        dfe->value = item->shared->value;
+        dfe->counter++;
     }
     else {
-        dfe->last_item = NULL;
+        dfe->item = NULL;
         dfe->name = NULL;
         dfe->value = NULL;
     }
 
+    if(unlikely(dfe->rw == DICTIONARY_LOCK_REENTRANT))
+        ll_recursive_unlock(dfe->dict, dfe->rw);
+
     return dfe->value;
 }
 
-usec_t dictionary_foreach_done(DICTFE *dfe) {
-    if(unlikely(!dfe || !dfe->dict)) return 0;
+void dictionary_foreach_done(DICTFE *dfe) {
+    if(unlikely(!dfe || !dfe->dict)) return;
 
-    if(unlikely(dfe->dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dfe->dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_foreach_next() on a destroyed dictionary");
-        return 0;
+        return;
     }
 
     // the item we just did
-    NAME_VALUE *nv = (NAME_VALUE *)dfe->last_item;
+    DICTIONARY_ITEM *item = dfe->item;
 
     // release it, so that it can possibly be deleted
-    if(likely(nv))
-        reference_counter_release(dfe->dict, nv, false);
+    if(likely(item)) {
+        dict_item_release_and_check_if_it_is_deleted_and_can_be_removed_under_this_lock_mode(dfe->dict, item, dfe->rw);
+        // item_release(dfe->dict, item);
+    }
+
+    if(likely(dfe->rw != DICTIONARY_LOCK_REENTRANT))
+        ll_recursive_unlock(dfe->dict, dfe->rw);
 
-    dictionary_unlock(dfe->dict, dfe->rw);
     dfe->dict = NULL;
-    dfe->last_item = NULL;
+    dfe->item = NULL;
     dfe->name = NULL;
     dfe->value = NULL;
-
-    usec_t usec = now_realtime_usec() - dfe->started_ut;
-    dfe->started_ut = 0;
-
-    return usec;
+    dfe->counter = 0;
 }
 
 // ----------------------------------------------------------------------------
-// API - walk through the dictionary
-// the dictionary is locked for reading while this happens
+// API - walk through the dictionary.
+// The dictionary is locked for reading while this happens
 // do not use other dictionary calls while walking the dictionary - deadlock!
 
-int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const char *name, void *entry, void *data), void *data) {
-    if(unlikely(!dict)) return 0;
+int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *entry, void *data), void *data) {
+    if(unlikely(!dict || !callback)) return 0;
 
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_walkthrough_rw() on a destroyed dictionary");
         return 0;
     }
 
-    dictionary_lock(dict, rw);
+    ll_recursive_lock(dict, rw);
 
     DICTIONARY_STATS_WALKTHROUGHS_PLUS1(dict);
 
     // written in such a way, that the callback can delete the active element
 
     int ret = 0;
-    NAME_VALUE *nv = dict->first_item, *nv_next;
-    while(nv) {
+    DICTIONARY_ITEM *item = dict->items.list, *item_next;
+    while(item) {
 
         // skip the deleted items
-        if(unlikely(nv->flags & NAME_VALUE_FLAG_DELETED)) {
-            nv = nv->next;
+        if(unlikely(!item_check_and_acquire(dict, item))) {
+            item = item->next;
             continue;
         }
 
-        // get a reference counter, so that our item will not be deleted
-        // while we are using it
-        reference_counter_acquire(dict, nv);
+        if(unlikely(rw == DICTIONARY_LOCK_REENTRANT))
+            ll_recursive_unlock(dict, rw);
 
-        int r = callback(namevalue_get_name(nv), nv->value, data);
+        int r = callback(item, item->shared->value, data);
+
+        if(unlikely(rw == DICTIONARY_LOCK_REENTRANT))
+            ll_recursive_lock(dict, rw);
 
         // since we have a reference counter, this item cannot be deleted
         // until we release the reference counter, so the pointers are there
-        nv_next = nv->next;
-        reference_counter_release(dict, nv, false);
+        item_next = item->next;
+
+        dict_item_release_and_check_if_it_is_deleted_and_can_be_removed_under_this_lock_mode(dict, item, rw);
+        // item_release(dict, item);
 
         if(unlikely(r < 0)) {
             ret = r;
@@ -1397,10 +2368,10 @@ int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const c
 
         ret += r;
 
-        nv = nv_next;
+        item = item_next;
     }
 
-    dictionary_unlock(dict, rw);
+    ll_recursive_unlock(dict, rw);
 
     return ret;
 }
@@ -1408,238 +2379,114 @@ int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const c
 // ----------------------------------------------------------------------------
 // sorted walkthrough
 
-static int dictionary_sort_compar(const void *nv1, const void *nv2) {
-    return strcmp(namevalue_get_name((*(NAME_VALUE **)nv1)), namevalue_get_name((*(NAME_VALUE **)nv2)));
+typedef int (*qsort_compar)(const void *item1, const void *item2);
+
+static int dictionary_sort_compar(const void *item1, const void *item2) {
+    return strcmp(item_get_name((*(DICTIONARY_ITEM **)item1)), item_get_name((*(DICTIONARY_ITEM **)item2)));
 }
 
-int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const char *name, void *entry, void *data), void *data) {
-    if(unlikely(!dict || !dict->entries)) return 0;
+int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *entry, void *data), void *data, dictionary_sorted_compar compar) {
+    if(unlikely(!dict || !callback)) return 0;
 
-    if(unlikely(dict->flags & DICTIONARY_FLAG_DESTROYED)) {
+    if(unlikely(is_dictionary_destroyed(dict))) {
         internal_error(true, "DICTIONARY: attempted to dictionary_sorted_walkthrough_rw() on a destroyed dictionary");
         return 0;
     }
 
-    dictionary_lock(dict, rw);
-    dictionary_defer_all_deletions_unsafe(dict, rw);
-
     DICTIONARY_STATS_WALKTHROUGHS_PLUS1(dict);
 
-    size_t count = dict->entries;
-    NAME_VALUE **array = mallocz(sizeof(NAME_VALUE *) * count);
+    ll_recursive_lock(dict, rw);
+    size_t entries = __atomic_load_n(&dict->entries, __ATOMIC_SEQ_CST);
+    DICTIONARY_ITEM **array = mallocz(sizeof(DICTIONARY_ITEM *) * entries);
 
     size_t i;
-    NAME_VALUE *nv;
-    for(nv = dict->first_item, i = 0; nv && i < count ;nv = nv->next) {
-        if(likely(!(nv->flags & NAME_VALUE_FLAG_DELETED)))
-            array[i++] = nv;
+    DICTIONARY_ITEM *item;
+    for(item = dict->items.list, i = 0; item && i < entries; item = item->next) {
+        if(likely(item_check_and_acquire(dict, item)))
+            array[i++] = item;
     }
+    ll_recursive_unlock(dict, rw);
 
-    internal_error(nv != NULL, "DICTIONARY: during sorting expected to have %zu items in dictionary, but there are more. Sorted results may be incomplete. Dictionary fails to maintain an accurate number of the number of entries it has.", count);
+    if(unlikely(i != entries))
+        entries = i;
 
-    if(unlikely(i != count)) {
-        internal_error(true, "DICTIONARY: during sorting expected to have %zu items in dictionary, but there are %zu. Sorted results may be incomplete. Dictionary fails to maintain an accurate number of the number of entries it has.", count, i);
-        count = i;
-    }
+    if(compar)
+        qsort(array, entries, sizeof(DICTIONARY_ITEM *), (qsort_compar)compar);
+    else
+        qsort(array, entries, sizeof(DICTIONARY_ITEM *), dictionary_sort_compar);
 
-    qsort(array, count, sizeof(NAME_VALUE *), dictionary_sort_compar);
+    bool callit = true;
+    int ret = 0, r;
+    for(i = 0; i < entries ;i++) {
+        item = array[i];
 
-    int ret = 0;
-    for(i = 0; i < count ;i++) {
-        nv = array[i];
-        if(likely(!(nv->flags & NAME_VALUE_FLAG_DELETED))) {
-            reference_counter_acquire(dict, nv);
-            int r = callback(namevalue_get_name(nv), nv->value, data);
-            reference_counter_release(dict, nv, false);
-            if (r < 0) {
-                ret = r;
-                break;
-            }
-            ret += r;
+        if(callit)
+            r = callback(item, item->shared->value, data);
+
+        dict_item_release_and_check_if_it_is_deleted_and_can_be_removed_under_this_lock_mode(dict, item, rw);
+        // item_release(dict, item);
+
+        if(r < 0) {
+            ret = r;
+            r = 0;
+
+            // stop calling the callback,
+            // but we have to continue, to release all the reference counters
+            callit = false;
         }
+        else
+            ret += r;
     }
 
-    dictionary_restore_all_deletions_unsafe(dict, rw);
-    dictionary_unlock(dict, rw);
     freez(array);
 
     return ret;
 }
 
 // ----------------------------------------------------------------------------
-// STRING implementation - dedup all STRINGs
+// THREAD_CACHE
 
-typedef struct string_entry {
-#ifdef DICTIONARY_WITH_AVL
-    avl_t avl_node;
-#endif
-    uint32_t length;    // the string length with the terminating '\0'
-    uint32_t refcount;  // how many times this string is used
-    const char str[];   // the string itself
-} STRING_ENTRY;
+static __thread Pvoid_t thread_cache_judy_array = NULL;
 
-#ifdef DICTIONARY_WITH_AVL
-static int string_entry_compare(void* a, void* b) {
-    return strcmp(((STRING_ENTRY *)a)->str, ((STRING_ENTRY *)b)->str);
-}
-
-static void *get_thread_static_string_entry(const char *name) {
-    static __thread size_t _length = 0;
-    static __thread STRING_ENTRY *_tmp = NULL;
+void *thread_cache_entry_get_or_set(void *key,
+                                    ssize_t key_length,
+                                    void *value,
+                                    void *(*transform_the_value_before_insert)(void *key, size_t key_length, void *value)
+                                    ) {
+    if(unlikely(!key || !key_length)) return NULL;
 
-    size_t size = sizeof(STRING_ENTRY) + strlen(name) + 1;
-    if(likely(_tmp && _length < size)) {
-        freez(_tmp);
-        _tmp = NULL;
-        _length = 0;
-    }
+    if(key_length == -1)
+        key_length = (ssize_t)strlen((char *)key) + 1;
 
-    if(unlikely(!_tmp)) {
-        _tmp = callocz(1, size);
-        _length = size;
+    JError_t J_Error;
+    Pvoid_t *Rc = JudyHSIns(&thread_cache_judy_array, key, key_length, &J_Error);
+    if (unlikely(Rc == PJERR)) {
+        fatal("THREAD_CACHE: Cannot insert entry to JudyHS, JU_ERRNO_* == %u, ID == %d",
+              JU_ERRNO(&J_Error), JU_ERRID(&J_Error));
     }
 
-    strcpy((char *)&_tmp->str[0], name);
-    return _tmp;
-}
-#endif
-
-DICTIONARY string_dictionary = {
-#ifdef DICTIONARY_WITH_AVL
-    .values_index = {
-        .root = NULL,
-        .compar = string_entry_compare
-    },
-    .get_thread_static_name_value = get_thread_static_string_entry,
-#endif
-
-    .flags = DICTIONARY_FLAG_EXCLUSIVE_ACCESS,
-    .rwlock = NETDATA_RWLOCK_INITIALIZER
-};
-
-static netdata_mutex_t string_mutex = NETDATA_MUTEX_INITIALIZER;
-
-STRING *string_dup(STRING *string) {
-    if(unlikely(!string)) return NULL;
-
-    STRING_ENTRY *se = (STRING_ENTRY *)string;
-    netdata_mutex_lock(&string_mutex);
-    se->refcount++;
-    netdata_mutex_unlock(&string_mutex);
-    return string;
-}
-
-STRING *string_strdupz(const char *str) {
-    if(unlikely(!str || !*str)) return NULL;
+    if(*Rc == 0) {
+        // new item added
 
-    netdata_mutex_lock(&string_mutex);
-
-    size_t length = strlen(str) + 1;
-    STRING_ENTRY *se;
-    STRING_ENTRY **ptr = (STRING_ENTRY **)hashtable_insert_unsafe(&string_dictionary, str, length);
-    if(unlikely(*ptr == 0)) {
-        // a new item added to the index
-        size_t mem_size = sizeof(STRING_ENTRY) + length;
-        se = mallocz(mem_size);
-        strcpy((char *)se->str, str);
-        se->length = length;
-        se->refcount = 1;
-        *ptr = se;
-        hashtable_inserted_name_value_unsafe(&string_dictionary, se);
-        string_dictionary.version++;
-        string_dictionary.inserts++;
-        string_dictionary.entries++;
-        string_dictionary.memory += (long)mem_size;
-    }
-    else {
-        // the item is already in the index
-        se = *ptr;
-        se->refcount++;
-        string_dictionary.searches++;
+        *Rc = (transform_the_value_before_insert) ? transform_the_value_before_insert(key, key_length, value) : value;
     }
 
-    netdata_mutex_unlock(&string_mutex);
-    return (STRING *)se;
+    return *Rc;
 }
 
-void string_freez(STRING *string) {
-    if(unlikely(!string)) return;
-    netdata_mutex_lock(&string_mutex);
-
-    STRING_ENTRY *se = (STRING_ENTRY *)string;
+void thread_cache_destroy(void) {
+    if(unlikely(!thread_cache_judy_array)) return;
 
-    if(se->refcount == 0)
-        fatal("STRING: tried to free string that has zero references.");
-
-    se->refcount--;
-    if(unlikely(se->refcount == 0)) {
-        if(hashtable_delete_unsafe(&string_dictionary, se->str, se->length, se) == 0)
-            error("STRING: INTERNAL ERROR: tried to delete '%s' that is not in the index", se->str);
-
-        size_t mem_size = sizeof(STRING_ENTRY) + se->length;
-        freez(se);
-        string_dictionary.version++;
-        string_dictionary.deletes++;
-        string_dictionary.entries--;
-        string_dictionary.memory -= (long)mem_size;
-    }
-
-    netdata_mutex_unlock(&string_mutex);
-}
-
-size_t string_length(STRING *string) {
-    if(unlikely(!string)) return 0;
-    return ((STRING_ENTRY *)string)->length - 1;
-}
-
-const char *string2str(STRING *string) {
-    if(unlikely(!string)) return "";
-    return ((STRING_ENTRY *)string)->str;
-}
-
-STRING *string_2way_merge(STRING *a, STRING *b) {
-    static STRING *X = NULL;
-
-    if(unlikely(!X)) {
-        X = string_strdupz("[x]");
+    JError_t J_Error;
+    Word_t ret = JudyHSFreeArray(&thread_cache_judy_array, &J_Error);
+    if(unlikely(ret == (Word_t) JERR)) {
+        error("THREAD_CACHE: Cannot destroy JudyHS, JU_ERRNO_* == %u, ID == %d",
+              JU_ERRNO(&J_Error), JU_ERRID(&J_Error));
     }
 
-    if(unlikely(a == b)) return string_dup(a);
-    if(unlikely(a == X)) return string_dup(a);
-    if(unlikely(b == X)) return string_dup(b);
-    if(unlikely(!a)) return string_dup(X);
-    if(unlikely(!b)) return string_dup(X);
-
-    size_t alen = string_length(a);
-    size_t blen = string_length(b);
-    size_t length = alen + blen + string_length(X) + 1;
-    char buf1[length + 1], buf2[length + 1], *dst1;
-    const char *s1, *s2;
-
-    s1 = string2str(a);
-    s2 = string2str(b);
-    dst1 = buf1;
-    for( ; *s1 && *s2 && *s1 == *s2 ;s1++, s2++)
-        *dst1++ = *s1;
-
-    *dst1 = '\0';
+    internal_error(true, "THREAD_CACHE: hash table freed %lu bytes", ret);
 
-    if(*s1 != '\0' || *s2 != '\0') {
-        *dst1++ = '[';
-        *dst1++ = 'x';
-        *dst1++ = ']';
-
-        s1 = &(string2str(a))[alen - 1];
-        s2 = &(string2str(b))[blen - 1];
-        char *dst2 = &buf2[length];
-        *dst2 = '\0';
-        for (; *s1 && *s2 && *s1 == *s2; s1--, s2--)
-            *(--dst2) = *s1;
-
-        strcpy(dst1, dst2);
-    }
-
-    return string_strdupz(buf1);
+    thread_cache_judy_array = NULL;
 }
 
 // ----------------------------------------------------------------------------
@@ -1656,7 +2503,7 @@ static char **dictionary_unittest_generate_names(size_t entries) {
     char **names = mallocz(sizeof(char *) * entries);
     for(size_t i = 0; i < entries ;i++) {
         char buf[25 + 1] = "";
-        snprintfz(buf, 25, "name.%zu.0123456789.%zu \t !@#$%%^&*(),./[]{}\\|~`", i, entries / 2 + i);
+        snprintfz(buf, 25, "name.%zu.0123456789.%zu!@#$%%^&*(),./[]{}\\|~`", i, entries / 2 + i);
         names[i] = strdupz(buf);
     }
     return names;
@@ -1686,12 +2533,12 @@ static size_t dictionary_unittest_set_clone(DICTIONARY *dict, char **names, char
 static size_t dictionary_unittest_set_null(DICTIONARY *dict, char **names, char **values, size_t entries) {
     (void)values;
     size_t errors = 0;
-    long i = 0;
-    for(; i < (long)entries ;i++) {
+    size_t i = 0;
+    for(; i < entries ;i++) {
         void *val = dictionary_set(dict, names[i], NULL, 0);
         if(val != NULL) { fprintf(stderr, ">>> %s() returns a non NULL value\n", __FUNCTION__); errors++; }
     }
-    if(dictionary_stats_entries(dict) != i) {
+    if(dictionary_entries(dict) != i) {
         fprintf(stderr, ">>> %s() dictionary items do not match\n", __FUNCTION__);
         errors++;
     }
@@ -1743,8 +2590,8 @@ static size_t dictionary_unittest_del_nonexisting(DICTIONARY *dict, char **names
     (void)names;
     size_t errors = 0;
     for(size_t i = 0; i < entries ;i++) {
-        int ret = dictionary_del(dict, values[i]);
-        if(ret != -1) { fprintf(stderr, ">>> %s() deleted non-existing item\n", __FUNCTION__); errors++; }
+        bool ret = dictionary_del(dict, values[i]);
+        if(ret) { fprintf(stderr, ">>> %s() deleted non-existing item\n", __FUNCTION__); errors++; }
     }
     return errors;
 }
@@ -1758,18 +2605,18 @@ static size_t dictionary_unittest_del_existing(DICTIONARY *dict, char **names, c
     size_t backward_from = middle_to, backward_to = entries;
 
     for(size_t i = forward_from; i < forward_to ;i++) {
-        int ret = dictionary_del(dict, names[i]);
-        if(ret == -1) { fprintf(stderr, ">>> %s() didn't delete (forward) existing item\n", __FUNCTION__); errors++; }
+        bool ret = dictionary_del(dict, names[i]);
+        if(!ret) { fprintf(stderr, ">>> %s() didn't delete (forward) existing item\n", __FUNCTION__); errors++; }
     }
 
     for(size_t i = middle_to - 1; i >= middle_from ;i--) {
-        int ret = dictionary_del(dict, names[i]);
-        if(ret == -1) { fprintf(stderr, ">>> %s() didn't delete (middle) existing item\n", __FUNCTION__); errors++; }
+        bool ret = dictionary_del(dict, names[i]);
+        if(!ret) { fprintf(stderr, ">>> %s() didn't delete (middle) existing item\n", __FUNCTION__); errors++; }
     }
 
     for(size_t i = backward_to - 1; i >= backward_from ;i--) {
-        int ret = dictionary_del(dict, names[i]);
-        if(ret == -1) { fprintf(stderr, ">>> %s() didn't delete (backward) existing item\n", __FUNCTION__); errors++; }
+        bool ret = dictionary_del(dict, names[i]);
+        if(!ret) { fprintf(stderr, ">>> %s() didn't delete (backward) existing item\n", __FUNCTION__); errors++; }
     }
 
     return errors;
@@ -1812,10 +2659,7 @@ static size_t dictionary_unittest_reset_dont_overwrite_nonclone(DICTIONARY *dict
     return errors;
 }
 
-static int dictionary_unittest_walkthrough_callback(const char *name, void *value, void *data) {
-    (void)name;
-    (void)value;
-    (void)data;
+static int dictionary_unittest_walkthrough_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value __maybe_unused, void *data __maybe_unused) {
     return 1;
 }
 
@@ -1827,10 +2671,10 @@ static size_t dictionary_unittest_walkthrough(DICTIONARY *dict, char **names, ch
     else return sum - entries;
 }
 
-static int dictionary_unittest_walkthrough_delete_this_callback(const char *name, void *value, void *data) {
-    (void)value;
+static int dictionary_unittest_walkthrough_delete_this_callback(const DICTIONARY_ITEM *item, void *value __maybe_unused, void *data) {
+    const char *name = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
 
-    if(dictionary_del_having_write_lock((DICTIONARY *)data, name) == -1)
+    if(!dictionary_del((DICTIONARY *)data, name))
         return 0;
 
     return 1;
@@ -1844,10 +2688,7 @@ static size_t dictionary_unittest_walkthrough_delete_this(DICTIONARY *dict, char
     else return sum - entries;
 }
 
-static int dictionary_unittest_walkthrough_stop_callback(const char *name, void *value, void *data) {
-    (void)name;
-    (void)value;
-    (void)data;
+static int dictionary_unittest_walkthrough_stop_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value __maybe_unused, void *data __maybe_unused) {
     return -1;
 }
 
@@ -1881,7 +2722,7 @@ static size_t dictionary_unittest_foreach_delete_this(DICTIONARY *dict, char **n
     size_t count = 0;
     char *item;
     dfe_start_write(dict, item)
-        if(dictionary_del_having_write_lock(dict, item_name) != -1) count++;
+        if(dictionary_del(dict, item_dfe.name)) count++;
     dfe_done(item);
 
     if(count > entries) return count - entries;
@@ -1907,7 +2748,22 @@ static usec_t dictionary_unittest_run_and_measure_time(DICTIONARY *dict, char *m
 
     if(callback == dictionary_unittest_destroy) dict = NULL;
 
-    fprintf(stderr, " %zu errors, %ld items in dictionary, %llu usec \n", errs, dict? dictionary_stats_entries(dict):0, dt);
+    long int found_ok = 0, found_deleted = 0, found_referenced = 0;
+    if(dict) {
+        DICTIONARY_ITEM *item;
+        DOUBLE_LINKED_LIST_FOREACH_FORWARD(dict->items.list, item, prev, next) {
+            if(item->refcount >= 0 && !(item ->flags & ITEM_FLAG_DELETED))
+                found_ok++;
+            else
+                found_deleted++;
+
+            if(item->refcount > 0)
+                found_referenced++;
+        }
+    }
+
+    fprintf(stderr, " %zu errors, %ld (found %ld) items in dictionary, %ld (found %ld) referenced, %ld (found %ld) deleted, %llu usec \n",
+            errs, dict?dict->entries:0, found_ok, dict?dict->referenced_items:0, found_referenced, dict?dict->pending_deletion_items:0, found_deleted, dt);
     *errors += errs;
     return dt;
 }
@@ -1943,23 +2799,24 @@ static void dictionary_unittest_nonclone(DICTIONARY *dict, char **names, char **
 }
 
 struct dictionary_unittest_sorting {
-    const char *oldname;
-    const char *oldvalue;
+    const char *old_name;
+    const char *old_value;
     size_t count;
 };
 
-static int dictionary_unittest_sorting_callback(const char *name, void *value, void *data) {
+static int dictionary_unittest_sorting_callback(const DICTIONARY_ITEM *item, void *value, void *data) {
+    const char *name = dictionary_acquired_item_name((DICTIONARY_ITEM *)item);
     struct dictionary_unittest_sorting *t = (struct dictionary_unittest_sorting *)data;
     const char *v = (const char *)value;
 
     int ret = 0;
-    if(t->oldname && strcmp(t->oldname, name) > 0) {
-        fprintf(stderr, "name '%s' should be after '%s'\n", t->oldname, name);
+    if(t->old_name && strcmp(t->old_name, name) > 0) {
+        fprintf(stderr, "name '%s' should be after '%s'\n", t->old_name, name);
         ret = 1;
     }
     t->count++;
-    t->oldname = name;
-    t->oldvalue = v;
+    t->old_name = name;
+    t->old_value = v;
 
     return ret;
 }
@@ -1967,7 +2824,7 @@ static int dictionary_unittest_sorting_callback(const char *name, void *value, v
 static size_t dictionary_unittest_sorted_walkthrough(DICTIONARY *dict, char **names, char **values, size_t entries) {
     (void)names;
     (void)values;
-    struct dictionary_unittest_sorting tmp = { .oldname = NULL, .oldvalue = NULL, .count = 0 };
+    struct dictionary_unittest_sorting tmp = { .old_name = NULL, .old_value = NULL, .count = 0 };
     size_t errors;
     errors = dictionary_sorted_walkthrough_read(dict, dictionary_unittest_sorting_callback, &tmp);
 
@@ -1989,62 +2846,94 @@ static void dictionary_unittest_null_dfe(DICTIONARY *dict, char **names, char **
 }
 
 
-static int check_dictionary_callback(const char *name, void *value, void *data) {
-    (void)name;
-    (void)value;
-    (void)data;
+static int unittest_check_dictionary_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value __maybe_unused, void *data __maybe_unused) {
     return 1;
 }
 
-static size_t check_dictionary(DICTIONARY *dict, size_t entries, size_t linked_list_members) {
+static size_t unittest_check_dictionary(const char *label, DICTIONARY *dict, size_t traversable, size_t active_items, size_t deleted_items, size_t referenced_items, size_t pending_deletion) {
     size_t errors = 0;
 
-    fprintf(stderr, "dictionary entries %ld, expected %zu...\t\t\t\t\t", dictionary_stats_entries(dict), entries);
-    if (dictionary_stats_entries(dict) != (long)entries) {
+    size_t ll = 0;
+    void *t;
+    dfe_start_read(dict, t)
+        ll++;
+    dfe_done(t);
+
+    fprintf(stderr, "DICT %-20s: dictionary foreach entries %zu, expected %zu...\t\t\t\t\t",
+            label, ll, traversable);
+    if(ll != traversable) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    size_t ll = 0;
-    void *t;
-    dfe_start_read(dict, t)
-        ll++;
-    dfe_done(t);
+    ll = dictionary_walkthrough_read(dict, unittest_check_dictionary_callback, NULL);
+    fprintf(stderr, "DICT %-20s: dictionary walkthrough entries %zu, expected %zu...\t\t\t\t",
+            label, ll, traversable);
+    if(ll != traversable) {
+        fprintf(stderr, "FAILED\n");
+        errors++;
+    }
+    else
+        fprintf(stderr, "OK\n");
 
-    fprintf(stderr, "dictionary foreach entries %zu, expected %zu...\t\t\t\t", ll, entries);
-    if(ll != entries) {
+    ll = dictionary_sorted_walkthrough_read(dict, unittest_check_dictionary_callback, NULL);
+    fprintf(stderr, "DICT %-20s: dictionary sorted walkthrough entries %zu, expected %zu...\t\t\t",
+            label, ll, traversable);
+    if(ll != traversable) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    ll = dictionary_walkthrough_read(dict, check_dictionary_callback, NULL);
-    fprintf(stderr, "dictionary walkthrough entries %zu, expected %zu...\t\t\t\t", ll, entries);
-    if(ll != entries) {
+    DICTIONARY_ITEM *item;
+    size_t active = 0, deleted = 0, referenced = 0, pending = 0;
+    for(item = dict->items.list; item; item = item->next) {
+        if(!(item->flags & ITEM_FLAG_DELETED) && !(item->shared->flags & ITEM_FLAG_DELETED))
+            active++;
+        else {
+            deleted++;
+
+            if(item->refcount == 0)
+                pending++;
+        }
+
+        if(item->refcount > 0)
+            referenced++;
+    }
+
+    fprintf(stderr, "DICT %-20s: dictionary active items reported %ld, counted %zu, expected %zu...\t\t\t",
+            label, dict->entries, active, active_items);
+    if(active != active_items || active != (size_t)dict->entries) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    ll = dictionary_sorted_walkthrough_read(dict, check_dictionary_callback, NULL);
-    fprintf(stderr, "dictionary sorted walkthrough entries %zu, expected %zu...\t\t\t", ll, entries);
-    if(ll != entries) {
+    fprintf(stderr, "DICT %-20s: dictionary deleted items counted %zu, expected %zu...\t\t\t\t",
+            label, deleted, deleted_items);
+    if(deleted != deleted_items) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    NAME_VALUE *nv;
-    for(ll = 0, nv = dict->first_item; nv ;nv = nv->next)
-        ll++;
+    fprintf(stderr, "DICT %-20s: dictionary referenced items reported %ld, counted %zu, expected %zu...\t\t",
+            label, dict->referenced_items, referenced, referenced_items);
+    if(referenced != referenced_items || dict->referenced_items != (long int)referenced) {
+        fprintf(stderr, "FAILED\n");
+        errors++;
+    }
+    else
+        fprintf(stderr, "OK\n");
 
-    fprintf(stderr, "dictionary linked list entries %zu, expected %zu...\t\t\t\t", ll, linked_list_members);
-    if(ll != linked_list_members) {
+    fprintf(stderr, "DICT %-20s: dictionary pending deletion items reported %ld, counted %zu, expected %zu...\t",
+            label, dict->pending_deletion_items, pending, pending_deletion);
+    if(pending != pending_deletion || pending != (size_t)dict->pending_deletion_items) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
@@ -2054,40 +2943,44 @@ static size_t check_dictionary(DICTIONARY *dict, size_t entries, size_t linked_l
     return errors;
 }
 
-static int check_name_value_callback(const char *name, void *value, void *data) {
-    (void)name;
+static int check_item_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data) {
     return value == data;
 }
 
-static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, const char *name, const char *value, unsigned refcount, NAME_VALUE_FLAGS deleted_flags, bool searchable, bool browsable, bool linked) {
+static size_t unittest_check_item(const char *label, DICTIONARY *dict,
+    DICTIONARY_ITEM *item, const char *name, const char *value, int refcount,
+    ITEM_FLAGS deleted_flags, bool searchable, bool browsable, bool linked) {
     size_t errors = 0;
 
-    fprintf(stderr, "NAME_VALUE name is '%s', expected '%s'...\t\t\t\t", namevalue_get_name(nv), name);
-    if(strcmp(namevalue_get_name(nv), name) != 0) {
+    fprintf(stderr, "ITEM %-20s: name is '%s', expected '%s'...\t\t\t\t\t\t", label, item_get_name(item), name);
+    if(strcmp(item_get_name(item), name) != 0) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    fprintf(stderr, "NAME_VALUE value is '%s', expected '%s'...\t\t\t", (const char *)nv->value, value);
-    if(strcmp((const char *)nv->value, value) != 0) {
+    fprintf(stderr, "ITEM %-20s: value is '%s', expected '%s'...\t\t\t\t\t", label, (const char *)item->shared->value, value);
+    if(strcmp((const char *)item->shared->value, value) != 0) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    fprintf(stderr, "NAME_VALUE refcount is %u, expected %u...\t\t\t\t\t", nv->refcount, refcount);
-    if (nv->refcount != refcount) {
+    fprintf(stderr, "ITEM %-20s: refcount is %d, expected %d...\t\t\t\t\t\t\t", label, item->refcount, refcount);
+    if (item->refcount != refcount) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
     else
         fprintf(stderr, "OK\n");
 
-    fprintf(stderr, "NAME_VALUE deleted flag is %s, expected %s...\t\t\t", (nv->flags & NAME_VALUE_FLAG_DELETED)?"TRUE":"FALSE", (deleted_flags & NAME_VALUE_FLAG_DELETED)?"TRUE":"FALSE");
-    if ((nv->flags & NAME_VALUE_FLAG_DELETED) != (deleted_flags & NAME_VALUE_FLAG_DELETED)) {
+    fprintf(stderr, "ITEM %-20s: deleted flag is %s, expected %s...\t\t\t\t\t", label,
+            (item->flags & ITEM_FLAG_DELETED || item->shared->flags & ITEM_FLAG_DELETED)?"true":"false",
+            (deleted_flags & ITEM_FLAG_DELETED)?"true":"false");
+
+    if ((item->flags & ITEM_FLAG_DELETED || item->shared->flags & ITEM_FLAG_DELETED) != (deleted_flags & ITEM_FLAG_DELETED)) {
         fprintf(stderr, "FAILED\n");
         errors++;
     }
@@ -2095,8 +2988,9 @@ static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, co
         fprintf(stderr, "OK\n");
 
     void *v = dictionary_get(dict, name);
-    bool found = v == nv->value;
-    fprintf(stderr, "NAME_VALUE searchable %5s, expected %5s...\t\t\t\t", found?"true":"false", searchable?"true":"false");
+    bool found = v == item->shared->value;
+    fprintf(stderr, "ITEM %-20s: searchable %5s, expected %5s...\t\t\t\t\t\t", label,
+            found?"true":"false", searchable?"true":"false");
     if(found != searchable) {
         fprintf(stderr, "FAILED\n");
         errors++;
@@ -2107,11 +3001,12 @@ static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, co
     found = false;
     void *t;
     dfe_start_read(dict, t) {
-        if(t == nv->value) found = true;
+        if(t == item->shared->value) found = true;
     }
     dfe_done(t);
 
-    fprintf(stderr, "NAME_VALUE dfe browsable %5s, expected %5s...\t\t\t", found?"true":"false", browsable?"true":"false");
+    fprintf(stderr, "ITEM %-20s: dfe browsable %5s, expected %5s...\t\t\t\t\t", label,
+            found?"true":"false", browsable?"true":"false");
     if(found != browsable) {
         fprintf(stderr, "FAILED\n");
         errors++;
@@ -2119,8 +3014,9 @@ static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, co
     else
         fprintf(stderr, "OK\n");
 
-    found = dictionary_walkthrough_read(dict, check_name_value_callback, nv->value);
-    fprintf(stderr, "NAME_VALUE walkthrough browsable %5s, expected %5s...\t\t", found?"true":"false", browsable?"true":"false");
+    found = dictionary_walkthrough_read(dict, check_item_callback, item->shared->value);
+    fprintf(stderr, "ITEM %-20s: walkthrough browsable %5s, expected %5s...\t\t\t\t", label,
+            found?"true":"false", browsable?"true":"false");
     if(found != browsable) {
         fprintf(stderr, "FAILED\n");
         errors++;
@@ -2128,8 +3024,9 @@ static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, co
     else
         fprintf(stderr, "OK\n");
 
-    found = dictionary_sorted_walkthrough_read(dict, check_name_value_callback, nv->value);
-    fprintf(stderr, "NAME_VALUE sorted walkthrough browsable %5s, expected %5s...\t", found?"true":"false", browsable?"true":"false");
+    found = dictionary_sorted_walkthrough_read(dict, check_item_callback, item->shared->value);
+    fprintf(stderr, "ITEM %-20s: sorted walkthrough browsable %5s, expected %5s...\t\t\t", label,
+            found?"true":"false", browsable?"true":"false");
     if(found != browsable) {
         fprintf(stderr, "FAILED\n");
         errors++;
@@ -2138,11 +3035,12 @@ static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, co
         fprintf(stderr, "OK\n");
 
     found = false;
-    NAME_VALUE *n;
-    for(n = dict->first_item; n ;n = n->next)
-        if(n == nv) found = true;
+    DICTIONARY_ITEM *n;
+    for(n = dict->items.list; n ;n = n->next)
+        if(n == item) found = true;
 
-    fprintf(stderr, "NAME_VALUE linked %5s, expected %5s...\t\t\t\t", found?"true":"false", linked?"true":"false");
+    fprintf(stderr, "ITEM %-20s: linked %5s, expected %5s...\t\t\t\t\t\t", label,
+            found?"true":"false", linked?"true":"false");
     if(found != linked) {
         fprintf(stderr, "FAILED\n");
         errors++;
@@ -2153,6 +3051,423 @@ static size_t check_name_value_deleted_flag(DICTIONARY *dict, NAME_VALUE *nv, co
     return errors;
 }
 
+struct thread_unittest {
+    int join;
+    DICTIONARY *dict;
+    int dups;
+};
+
+static void *unittest_dict_thread(void *arg) {
+    struct thread_unittest *tu = arg;
+    for(; 1 ;) {
+        if(__atomic_load_n(&tu->join, __ATOMIC_RELAXED))
+            break;
+
+        DICT_ITEM_CONST DICTIONARY_ITEM *item =
+            dictionary_set_and_acquire_item_advanced(tu->dict, "dict thread checking 1234567890",
+                                                     -1, NULL, 0, NULL);
+
+
+        dictionary_get(tu->dict, dictionary_acquired_item_name(item));
+
+        void *t1;
+        dfe_start_write(tu->dict, t1) {
+
+            // this should delete the referenced item
+            dictionary_del(tu->dict, t1_dfe.name);
+
+            void *t2;
+            dfe_start_write(tu->dict, t2) {
+                // this should add another
+                dictionary_set(tu->dict, t2_dfe.name, NULL, 0);
+
+                dictionary_get(tu->dict, dictionary_acquired_item_name(item));
+
+                // and this should delete it again
+                dictionary_del(tu->dict, t2_dfe.name);
+            }
+            dfe_done(t2);
+
+            // this should fail to add it
+            dictionary_set(tu->dict, t1_dfe.name, NULL, 0);
+            dictionary_del(tu->dict, t1_dfe.name);
+        }
+        dfe_done(t1);
+
+        for(int i = 0; i < tu->dups ; i++) {
+            dictionary_acquired_item_dup(tu->dict, item);
+            dictionary_get(tu->dict, dictionary_acquired_item_name(item));
+        }
+
+        for(int i = 0; i < tu->dups ; i++) {
+            dictionary_acquired_item_release(tu->dict, item);
+            dictionary_del(tu->dict, dictionary_acquired_item_name(item));
+        }
+
+        dictionary_acquired_item_release(tu->dict, item);
+        dictionary_del(tu->dict, "dict thread checking 1234567890");
+
+        // test concurrent deletions and flushes
+        {
+            if(gettid() % 2) {
+                char buf [256 + 1];
+
+                for (int i = 0; i < 1000; i++) {
+                    snprintfz(buf, 256, "del/flush test %d", i);
+                    dictionary_set(tu->dict, buf, NULL, 0);
+                }
+
+                for (int i = 0; i < 1000; i++) {
+                    snprintfz(buf, 256, "del/flush test %d", i);
+                    dictionary_del(tu->dict, buf);
+                }
+            }
+            else {
+                for (int i = 0; i < 10; i++) {
+                    dictionary_flush(tu->dict);
+                }
+            }
+        }
+    }
+
+    return arg;
+}
+
+static int dictionary_unittest_threads() {
+
+    struct thread_unittest tu = {
+        .join = 0,
+        .dict = NULL,
+        .dups = 1,
+    };
+
+    // threads testing of dictionary
+    tu.dict = dictionary_create(DICT_OPTION_DONT_OVERWRITE_VALUE);
+    time_t seconds_to_run = 5;
+    int threads_to_create = 2;
+    fprintf(
+        stderr,
+        "\nChecking dictionary concurrency with %d threads for %lld seconds...\n",
+        threads_to_create,
+        (long long)seconds_to_run);
+
+    netdata_thread_t threads[threads_to_create];
+    tu.join = 0;
+    for (int i = 0; i < threads_to_create; i++) {
+        char buf[100 + 1];
+        snprintf(buf, 100, "dict%d", i);
+        netdata_thread_create(
+            &threads[i],
+            buf,
+            NETDATA_THREAD_OPTION_DONT_LOG | NETDATA_THREAD_OPTION_JOINABLE,
+            unittest_dict_thread,
+            &tu);
+    }
+    sleep_usec(seconds_to_run * USEC_PER_SEC);
+
+    __atomic_store_n(&tu.join, 1, __ATOMIC_RELAXED);
+    for (int i = 0; i < threads_to_create; i++) {
+        void *retval;
+        netdata_thread_join(threads[i], &retval);
+    }
+
+    fprintf(stderr,
+            "inserts %zu"
+            ", deletes %zu"
+            ", searches %zu"
+            ", resets %zu"
+            ", flushes %zu"
+            ", entries %ld"
+            ", referenced_items %ld"
+            ", pending deletions %ld"
+            ", check spins %zu"
+            ", insert spins %zu"
+            ", delete spins %zu"
+            ", search ignores %zu"
+            "\n",
+            tu.dict->stats->ops.inserts,
+            tu.dict->stats->ops.deletes,
+            tu.dict->stats->ops.searches,
+            tu.dict->stats->ops.resets,
+            tu.dict->stats->ops.flushes,
+            tu.dict->entries,
+            tu.dict->referenced_items,
+            tu.dict->pending_deletion_items,
+            tu.dict->stats->spin_locks.use_spins,
+            tu.dict->stats->spin_locks.insert_spins,
+            tu.dict->stats->spin_locks.delete_spins,
+            tu.dict->stats->spin_locks.search_spins
+    );
+    dictionary_destroy(tu.dict);
+    tu.dict = NULL;
+
+    return 0;
+}
+
+struct thread_view_unittest {
+    int join;
+    DICTIONARY *master;
+    DICTIONARY *view;
+    DICTIONARY_ITEM *item_master;
+    int dups;
+};
+
+static void *unittest_dict_master_thread(void *arg) {
+    struct thread_view_unittest *tv = arg;
+
+    DICTIONARY_ITEM *item = NULL;
+    int loops = 0;
+    while(!__atomic_load_n(&tv->join, __ATOMIC_SEQ_CST)) {
+
+        if(!item)
+            item = dictionary_set_and_acquire_item(tv->master, "ITEM1", "123", strlen("123") + 1);
+
+        if(__atomic_load_n(&tv->item_master, __ATOMIC_SEQ_CST) != NULL) {
+            dictionary_acquired_item_release(tv->master, item);
+            dictionary_del(tv->master, "ITEM1");
+            item = NULL;
+            loops++;
+            continue;
+        }
+
+        dictionary_acquired_item_dup(tv->master, item); // for the view thread
+        __atomic_store_n(&tv->item_master, item, __ATOMIC_SEQ_CST);
+        dictionary_del(tv->master, "ITEM1");
+
+
+        for(int i = 0; i < tv->dups + loops ; i++) {
+            dictionary_acquired_item_dup(tv->master, item);
+        }
+
+        for(int i = 0; i < tv->dups + loops ; i++) {
+            dictionary_acquired_item_release(tv->master, item);
+        }
+
+        dictionary_acquired_item_release(tv->master, item);
+
+        item = NULL;
+        loops = 0;
+    }
+
+    return arg;
+}
+
+static void *unittest_dict_view_thread(void *arg) {
+    struct thread_view_unittest *tv = arg;
+
+    DICTIONARY_ITEM *m_item = NULL;
+
+    while(!__atomic_load_n(&tv->join, __ATOMIC_SEQ_CST)) {
+        if(!(m_item = __atomic_load_n(&tv->item_master, __ATOMIC_SEQ_CST)))
+            continue;
+
+        DICTIONARY_ITEM *v_item = dictionary_view_set_and_acquire_item(tv->view, "ITEM2", m_item);
+        dictionary_acquired_item_release(tv->master, m_item);
+        __atomic_store_n(&tv->item_master, NULL, __ATOMIC_SEQ_CST);
+
+        for(int i = 0; i < tv->dups ; i++) {
+            dictionary_acquired_item_dup(tv->view, v_item);
+        }
+
+        for(int i = 0; i < tv->dups ; i++) {
+            dictionary_acquired_item_release(tv->view, v_item);
+        }
+
+        dictionary_del(tv->view, "ITEM2");
+
+        while(!__atomic_load_n(&tv->join, __ATOMIC_SEQ_CST) && !(m_item = __atomic_load_n(&tv->item_master, __ATOMIC_SEQ_CST))) {
+            dictionary_acquired_item_dup(tv->view, v_item);
+            dictionary_acquired_item_release(tv->view, v_item);
+        }
+
+        dictionary_acquired_item_release(tv->view, v_item);
+    }
+
+    return arg;
+}
+
+static int dictionary_unittest_view_threads() {
+
+    struct thread_view_unittest tv = {
+        .join = 0,
+        .master = NULL,
+        .view = NULL,
+        .item_master = NULL,
+        .dups = 1,
+    };
+
+    // threads testing of dictionary
+    struct dictionary_stats stats_master = {};
+    struct dictionary_stats stats_view = {};
+    tv.master = dictionary_create_advanced(DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_DONT_OVERWRITE_VALUE, &stats_master);
+    tv.view = dictionary_create_view(tv.master);
+    tv.view->stats = &stats_view;
+
+    time_t seconds_to_run = 5;
+    fprintf(
+        stderr,
+        "\nChecking dictionary concurrency with 1 master and 1 view threads for %lld seconds...\n",
+        (long long)seconds_to_run);
+
+    netdata_thread_t master_thread, view_thread;
+    tv.join = 0;
+
+    netdata_thread_create(
+        &master_thread,
+        "master",
+        NETDATA_THREAD_OPTION_DONT_LOG | NETDATA_THREAD_OPTION_JOINABLE,
+        unittest_dict_master_thread,
+        &tv);
+
+    netdata_thread_create(
+        &view_thread,
+        "view",
+        NETDATA_THREAD_OPTION_DONT_LOG | NETDATA_THREAD_OPTION_JOINABLE,
+        unittest_dict_view_thread,
+        &tv);
+
+    sleep_usec(seconds_to_run * USEC_PER_SEC);
+
+    __atomic_store_n(&tv.join, 1, __ATOMIC_RELAXED);
+    void *retval;
+    netdata_thread_join(view_thread, &retval);
+    netdata_thread_join(master_thread, &retval);
+
+    fprintf(stderr,
+            "MASTER: inserts %zu"
+            ", deletes %zu"
+            ", searches %zu"
+            ", resets %zu"
+            ", entries %ld"
+            ", referenced_items %ld"
+            ", pending deletions %ld"
+            ", check spins %zu"
+            ", insert spins %zu"
+            ", delete spins %zu"
+            ", search ignores %zu"
+            "\n",
+            stats_master.ops.inserts,
+            stats_master.ops.deletes,
+            stats_master.ops.searches,
+            stats_master.ops.resets,
+            tv.master->entries,
+            tv.master->referenced_items,
+            tv.master->pending_deletion_items,
+            stats_master.spin_locks.use_spins,
+            stats_master.spin_locks.insert_spins,
+            stats_master.spin_locks.delete_spins,
+            stats_master.spin_locks.search_spins
+    );
+    fprintf(stderr,
+            "VIEW  : inserts %zu"
+            ", deletes %zu"
+            ", searches %zu"
+            ", resets %zu"
+            ", entries %ld"
+            ", referenced_items %ld"
+            ", pending deletions %ld"
+            ", check spins %zu"
+            ", insert spins %zu"
+            ", delete spins %zu"
+            ", search ignores %zu"
+            "\n",
+            stats_view.ops.inserts,
+            stats_view.ops.deletes,
+            stats_view.ops.searches,
+            stats_view.ops.resets,
+            tv.view->entries,
+            tv.view->referenced_items,
+            tv.view->pending_deletion_items,
+            stats_view.spin_locks.use_spins,
+            stats_view.spin_locks.insert_spins,
+            stats_view.spin_locks.delete_spins,
+            stats_view.spin_locks.search_spins
+    );
+    dictionary_destroy(tv.master);
+    dictionary_destroy(tv.view);
+
+    return 0;
+}
+
+size_t dictionary_unittest_views(void) {
+    size_t errors = 0;
+    struct dictionary_stats stats = {};
+    DICTIONARY *master = dictionary_create_advanced(DICT_OPTION_NONE, &stats);
+    DICTIONARY *view = dictionary_create_view(master);
+
+    fprintf(stderr, "\n\nChecking dictionary views...\n");
+
+    // Add an item to both master and view, then remove the view first and the master second
+    fprintf(stderr, "\nPASS 1: Adding 1 item to master:\n");
+    DICTIONARY_ITEM *item1_on_master = dictionary_set_and_acquire_item(master, "KEY 1", "VALUE1", strlen("VALUE1") + 1);
+    errors += unittest_check_dictionary("master", master, 1, 1, 0, 1, 0);
+    errors += unittest_check_item("master", master, item1_on_master, "KEY 1", item1_on_master->shared->value, 1, ITEM_FLAG_NONE, true, true, true);
+
+    fprintf(stderr, "\nPASS 1: Adding master item to view:\n");
+    DICTIONARY_ITEM *item1_on_view = dictionary_view_set_and_acquire_item(view, "KEY 1 ON VIEW", item1_on_master);
+    errors += unittest_check_dictionary("view", view, 1, 1, 0, 1, 0);
+    errors += unittest_check_item("view", view, item1_on_view, "KEY 1 ON VIEW", item1_on_master->shared->value, 1, ITEM_FLAG_NONE, true, true, true);
+
+    fprintf(stderr, "\nPASS 1: Deleting view item:\n");
+    dictionary_del(view, "KEY 1 ON VIEW");
+    errors += unittest_check_dictionary("master", master, 1, 1, 0, 1, 0);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 1, 0);
+    errors += unittest_check_item("master", master, item1_on_master, "KEY 1", item1_on_master->shared->value, 1, ITEM_FLAG_NONE, true, true, true);
+    errors += unittest_check_item("view", view, item1_on_view, "KEY 1 ON VIEW", item1_on_master->shared->value, 1, ITEM_FLAG_DELETED, false, false, true);
+
+    fprintf(stderr, "\nPASS 1: Releasing the deleted view item:\n");
+    dictionary_acquired_item_release(view, item1_on_view);
+    errors += unittest_check_dictionary("master", master, 1, 1, 0, 1, 0);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 0, 1);
+    errors += unittest_check_item("master", master, item1_on_master, "KEY 1", item1_on_master->shared->value, 1, ITEM_FLAG_NONE, true, true, true);
+
+    fprintf(stderr, "\nPASS 1: Releasing the acquired master item:\n");
+    dictionary_acquired_item_release(master, item1_on_master);
+    errors += unittest_check_dictionary("master", master, 1, 1, 0, 0, 0);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 0, 1);
+    errors += unittest_check_item("master", master, item1_on_master, "KEY 1", item1_on_master->shared->value, 0, ITEM_FLAG_NONE, true, true, true);
+
+    fprintf(stderr, "\nPASS 1: Deleting the released master item:\n");
+    dictionary_del(master, "KEY 1");
+    errors += unittest_check_dictionary("master", master, 0, 0, 0, 0, 0);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 0, 1);
+
+    // The other way now:
+    // Add an item to both master and view, then remove the master first and verify it is deleted on the view also
+    fprintf(stderr, "\nPASS 2: Adding 1 item to master:\n");
+    item1_on_master = dictionary_set_and_acquire_item(master, "KEY 1", "VALUE1", strlen("VALUE1") + 1);
+    errors += unittest_check_dictionary("master", master, 1, 1, 0, 1, 0);
+    errors += unittest_check_item("master", master, item1_on_master, "KEY 1", item1_on_master->shared->value, 1, ITEM_FLAG_NONE, true, true, true);
+
+    fprintf(stderr, "\nPASS 2: Adding master item to view:\n");
+    item1_on_view = dictionary_view_set_and_acquire_item(view, "KEY 1 ON VIEW", item1_on_master);
+    errors += unittest_check_dictionary("view", view, 1, 1, 0, 1, 0);
+    errors += unittest_check_item("view", view, item1_on_view, "KEY 1 ON VIEW", item1_on_master->shared->value, 1, ITEM_FLAG_NONE, true, true, true);
+
+    fprintf(stderr, "\nPASS 2: Deleting master item:\n");
+    dictionary_del(master, "KEY 1");
+    dictionary_version(view);
+    errors += unittest_check_dictionary("master", master, 0, 0, 1, 1, 0);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 1, 0);
+    errors += unittest_check_item("master", master, item1_on_master, "KEY 1", item1_on_master->shared->value, 1, ITEM_FLAG_DELETED, false, false, true);
+    errors += unittest_check_item("view", view, item1_on_view, "KEY 1 ON VIEW", item1_on_master->shared->value, 1, ITEM_FLAG_DELETED, false, false, true);
+
+    fprintf(stderr, "\nPASS 2: Releasing the acquired master item:\n");
+    dictionary_acquired_item_release(master, item1_on_master);
+    errors += unittest_check_dictionary("master", master, 0, 0, 1, 0, 1);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 1, 0);
+    errors += unittest_check_item("view", view, item1_on_view, "KEY 1 ON VIEW", item1_on_master->shared->value, 1, ITEM_FLAG_DELETED, false, false, true);
+
+    fprintf(stderr, "\nPASS 2: Releasing the deleted view item:\n");
+    dictionary_acquired_item_release(view, item1_on_view);
+    errors += unittest_check_dictionary("master", master, 0, 0, 1, 0, 1);
+    errors += unittest_check_dictionary("view", view, 0, 0, 1, 0, 1);
+
+    dictionary_destroy(master);
+    dictionary_destroy(view);
+    return errors;
+}
+
 int dictionary_unittest(size_t entries) {
     if(entries < 10) entries = 10;
 
@@ -2164,23 +3479,28 @@ int dictionary_unittest(size_t entries) {
     char **values = dictionary_unittest_generate_values(entries);
 
     fprintf(stderr, "\nCreating dictionary single threaded, clone, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
+    dict = dictionary_create(DICT_OPTION_SINGLE_THREADED);
     dictionary_unittest_clone(dict, names, values, entries, &errors);
 
     fprintf(stderr, "\nCreating dictionary multi threaded, clone, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_NONE);
+    dict = dictionary_create(DICT_OPTION_NONE);
     dictionary_unittest_clone(dict, names, values, entries, &errors);
 
     fprintf(stderr, "\nCreating dictionary single threaded, non-clone, add-in-front options, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED|DICTIONARY_FLAG_NAME_LINK_DONT_CLONE|DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE|DICTIONARY_FLAG_ADD_IN_FRONT);
+    dict = dictionary_create(
+        DICT_OPTION_SINGLE_THREADED | DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_VALUE_LINK_DONT_CLONE |
+        DICT_OPTION_ADD_IN_FRONT);
     dictionary_unittest_nonclone(dict, names, values, entries, &errors);
 
     fprintf(stderr, "\nCreating dictionary multi threaded, non-clone, add-in-front options, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_NAME_LINK_DONT_CLONE|DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE|DICTIONARY_FLAG_ADD_IN_FRONT);
+    dict = dictionary_create(
+        DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_VALUE_LINK_DONT_CLONE | DICT_OPTION_ADD_IN_FRONT);
     dictionary_unittest_nonclone(dict, names, values, entries, &errors);
 
     fprintf(stderr, "\nCreating dictionary single-threaded, non-clone, don't overwrite options, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED|DICTIONARY_FLAG_NAME_LINK_DONT_CLONE|DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE|DICTIONARY_FLAG_DONT_OVERWRITE_VALUE);
+    dict = dictionary_create(
+        DICT_OPTION_SINGLE_THREADED | DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_VALUE_LINK_DONT_CLONE |
+        DICT_OPTION_DONT_OVERWRITE_VALUE);
     dictionary_unittest_run_and_measure_time(dict, "adding entries", names, values, entries, &errors, dictionary_unittest_set_nonclone);
     dictionary_unittest_run_and_measure_time(dict, "resetting non-overwrite entries", names, values, entries, &errors, dictionary_unittest_reset_dont_overwrite_nonclone);
     dictionary_unittest_run_and_measure_time(dict, "traverse foreach read loop", names, values, entries, &errors, dictionary_unittest_foreach);
@@ -2189,13 +3509,15 @@ int dictionary_unittest(size_t entries) {
     dictionary_unittest_run_and_measure_time(dict, "destroying full dictionary", names, values, entries, &errors, dictionary_unittest_destroy);
 
     fprintf(stderr, "\nCreating dictionary multi-threaded, non-clone, don't overwrite options, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_NAME_LINK_DONT_CLONE|DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE|DICTIONARY_FLAG_DONT_OVERWRITE_VALUE);
+    dict = dictionary_create(
+        DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_VALUE_LINK_DONT_CLONE | DICT_OPTION_DONT_OVERWRITE_VALUE);
     dictionary_unittest_run_and_measure_time(dict, "adding entries", names, values, entries, &errors, dictionary_unittest_set_nonclone);
     dictionary_unittest_run_and_measure_time(dict, "walkthrough write delete this", names, values, entries, &errors, dictionary_unittest_walkthrough_delete_this);
     dictionary_unittest_run_and_measure_time(dict, "destroying empty dictionary", names, values, entries, &errors, dictionary_unittest_destroy);
 
     fprintf(stderr, "\nCreating dictionary multi-threaded, non-clone, don't overwrite options, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_NAME_LINK_DONT_CLONE|DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE|DICTIONARY_FLAG_DONT_OVERWRITE_VALUE);
+    dict = dictionary_create(
+        DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_VALUE_LINK_DONT_CLONE | DICT_OPTION_DONT_OVERWRITE_VALUE);
     dictionary_unittest_run_and_measure_time(dict, "adding entries", names, values, entries, &errors, dictionary_unittest_set_nonclone);
     dictionary_unittest_run_and_measure_time(dict, "foreach write delete this", names, values, entries, &errors, dictionary_unittest_foreach_delete_this);
     dictionary_unittest_run_and_measure_time(dict, "traverse foreach read loop empty", names, values, 0, &errors, dictionary_unittest_foreach);
@@ -2203,208 +3525,100 @@ int dictionary_unittest(size_t entries) {
     dictionary_unittest_run_and_measure_time(dict, "destroying empty dictionary", names, values, entries, &errors, dictionary_unittest_destroy);
 
     fprintf(stderr, "\nCreating dictionary single threaded, clone, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
+    dict = dictionary_create(DICT_OPTION_SINGLE_THREADED);
     dictionary_unittest_sorting(dict, names, values, entries, &errors);
     dictionary_unittest_run_and_measure_time(dict, "destroying full dictionary", names, values, entries, &errors, dictionary_unittest_destroy);
 
     fprintf(stderr, "\nCreating dictionary single threaded, clone, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
+    dict = dictionary_create(DICT_OPTION_SINGLE_THREADED);
     dictionary_unittest_null_dfe(dict, names, values, entries, &errors);
     dictionary_unittest_run_and_measure_time(dict, "destroying full dictionary", names, values, entries, &errors, dictionary_unittest_destroy);
 
     fprintf(stderr, "\nCreating dictionary single threaded, noclone, %zu items\n", entries);
-    dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED|DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE);
+    dict = dictionary_create(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_VALUE_LINK_DONT_CLONE);
     dictionary_unittest_null_dfe(dict, names, values, entries, &errors);
     dictionary_unittest_run_and_measure_time(dict, "destroying full dictionary", names, values, entries, &errors, dictionary_unittest_destroy);
 
     // check reference counters
     {
         fprintf(stderr, "\nTesting reference counters:\n");
-        dict = dictionary_create(DICTIONARY_FLAG_NONE|DICTIONARY_FLAG_NAME_LINK_DONT_CLONE);
-        errors += check_dictionary(dict, 0, 0);
+        dict = dictionary_create(DICT_OPTION_NONE | DICT_OPTION_NAME_LINK_DONT_CLONE);
+        errors += unittest_check_dictionary("", dict, 0, 0, 0, 0, 0);
 
         fprintf(stderr, "\nAdding test item to dictionary and acquiring it\n");
         dictionary_set(dict, "test", "ITEM1", 6);
-        NAME_VALUE *nv = (NAME_VALUE *)dictionary_get_and_acquire_item(dict, "test");
+        DICTIONARY_ITEM *item = (DICTIONARY_ITEM *)dictionary_get_and_acquire_item(dict, "test");
 
-        errors += check_dictionary(dict, 1, 1);
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_NONE, true, true, true);
+        errors += unittest_check_dictionary("", dict, 1, 1, 0, 1, 0);
+        errors += unittest_check_item("ACQUIRED", dict, item, "test", "ITEM1", 1, ITEM_FLAG_NONE, true, true, true);
 
         fprintf(stderr, "\nChecking that reference counters are increased:\n");
         void *t;
         dfe_start_read(dict, t) {
-            errors += check_dictionary(dict, 1, 1);
-            errors +=
-                check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 2, NAME_VALUE_FLAG_NONE, true, true, true);
+            errors += unittest_check_dictionary("", dict, 1, 1, 0, 1, 0);
+            errors += unittest_check_item("ACQUIRED TRAVERSAL", dict, item, "test", "ITEM1", 2, ITEM_FLAG_NONE, true, true, true);
         }
         dfe_done(t);
 
         fprintf(stderr, "\nChecking that reference counters are decreased:\n");
-        errors += check_dictionary(dict, 1, 1);
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_NONE, true, true, true);
+        errors += unittest_check_dictionary("", dict, 1, 1, 0, 1, 0);
+        errors += unittest_check_item("ACQUIRED TRAVERSAL 2", dict, item, "test", "ITEM1", 1, ITEM_FLAG_NONE, true, true, true);
 
         fprintf(stderr, "\nDeleting the item we have acquired:\n");
         dictionary_del(dict, "test");
 
-        errors += check_dictionary(dict, 0, 1);
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_DELETED, false, false, true);
+        errors += unittest_check_dictionary("", dict, 0, 0, 1, 1, 0);
+        errors += unittest_check_item("DELETED", dict, item, "test", "ITEM1", 1, ITEM_FLAG_DELETED, false, false, true);
 
         fprintf(stderr, "\nAdding another item with the same name of the item we deleted, while being acquired:\n");
         dictionary_set(dict, "test", "ITEM2", 6);
-        errors += check_dictionary(dict, 1, 2);
+        errors += unittest_check_dictionary("", dict, 1, 1, 1, 1, 0);
 
         fprintf(stderr, "\nAcquiring the second item:\n");
-        NAME_VALUE *nv2 = (NAME_VALUE *)dictionary_get_and_acquire_item(dict, "test");
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_DELETED, false, false, true);
-        errors += check_name_value_deleted_flag(dict, nv2, "test", "ITEM2", 1, NAME_VALUE_FLAG_NONE, true, true, true);
+        DICTIONARY_ITEM *item2 = (DICTIONARY_ITEM *)dictionary_get_and_acquire_item(dict, "test");
+        errors += unittest_check_item("FIRST", dict, item, "test", "ITEM1", 1, ITEM_FLAG_DELETED, false, false, true);
+        errors += unittest_check_item("SECOND", dict, item2, "test", "ITEM2", 1, ITEM_FLAG_NONE, true, true, true);
+        errors += unittest_check_dictionary("", dict, 1, 1, 1, 2, 0);
 
         fprintf(stderr, "\nReleasing the second item (the first is still acquired):\n");
-        dictionary_acquired_item_release(dict, (DICTIONARY_ITEM *)nv2);
-        errors += check_dictionary(dict, 1, 2);
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_DELETED, false, false, true);
-        errors += check_name_value_deleted_flag(dict, nv2, "test", "ITEM2", 0, NAME_VALUE_FLAG_NONE, true, true, true);
+        dictionary_acquired_item_release(dict, (DICTIONARY_ITEM *)item2);
+        errors += unittest_check_dictionary("", dict, 1, 1, 1, 1, 0);
+        errors += unittest_check_item("FIRST", dict, item, "test", "ITEM1", 1, ITEM_FLAG_DELETED, false, false, true);
+        errors += unittest_check_item("SECOND RELEASED", dict, item2, "test", "ITEM2", 0, ITEM_FLAG_NONE, true, true, true);
 
         fprintf(stderr, "\nDeleting the second item (the first is still acquired):\n");
         dictionary_del(dict, "test");
-        errors += check_dictionary(dict, 0, 1);
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_DELETED, false, false, true);
+        errors += unittest_check_dictionary("", dict, 0, 0, 1, 1, 0);
+        errors += unittest_check_item("ACQUIRED DELETED", dict, item, "test", "ITEM1", 1, ITEM_FLAG_DELETED, false, false, true);
 
         fprintf(stderr, "\nReleasing the first item (which we have already deleted):\n");
-        dictionary_acquired_item_release(dict, (DICTIONARY_ITEM *)nv);
-        errors += check_dictionary(dict, 0, 0);
+        dictionary_acquired_item_release(dict, (DICTIONARY_ITEM *)item);
+        dfe_start_write(dict, item) ; dfe_done(item);
+        errors += unittest_check_dictionary("", dict, 0, 0, 1, 0, 1);
 
         fprintf(stderr, "\nAdding again the test item to dictionary and acquiring it\n");
         dictionary_set(dict, "test", "ITEM1", 6);
-        nv = (NAME_VALUE *)dictionary_get_and_acquire_item(dict, "test");
+        item = (DICTIONARY_ITEM *)dictionary_get_and_acquire_item(dict, "test");
 
-        errors += check_dictionary(dict, 1, 1);
-        errors += check_name_value_deleted_flag(dict, nv, "test", "ITEM1", 1, NAME_VALUE_FLAG_NONE, true, true, true);
+        errors += unittest_check_dictionary("", dict, 1, 1, 0, 1, 0);
+        errors += unittest_check_item("RE-ADDITION", dict, item, "test", "ITEM1", 1, ITEM_FLAG_NONE, true, true, true);
 
         fprintf(stderr, "\nDestroying the dictionary while we have acquired an item\n");
         dictionary_destroy(dict);
 
         fprintf(stderr, "Releasing the item (on a destroyed dictionary)\n");
-        dictionary_acquired_item_release(dict, (DICTIONARY_ITEM *)nv);
-        nv = NULL;
+        dictionary_acquired_item_release(dict, (DICTIONARY_ITEM *)item);
+        item = NULL;
         dict = NULL;
     }
 
-    // check string
-    {
-        long string_entries_starting = dictionary_stats_entries(&string_dictionary);
-
-        fprintf(stderr, "\nChecking strings...\n");
-
-        STRING *s1 = string_strdupz("hello unittest");
-        STRING *s2 = string_strdupz("hello unittest");
-        if(s1 != s2) {
-            errors++;
-            fprintf(stderr, "ERROR: duplicating strings are not deduplicated\n");
-        }
-        else
-            fprintf(stderr, "OK: duplicating string are deduplicated\n");
-
-        STRING *s3 = string_dup(s1);
-        if(s3 != s1) {
-            errors++;
-            fprintf(stderr, "ERROR: cloning strings are not deduplicated\n");
-        }
-        else
-            fprintf(stderr, "OK: cloning string are deduplicated\n");
-
-        STRING_ENTRY *se = (STRING_ENTRY *)s1;
-        if(se->refcount != 3) {
-            errors++;
-            fprintf(stderr, "ERROR: string refcount is not 3\n");
-        }
-        else
-            fprintf(stderr, "OK: string refcount is 3\n");
-
-        STRING *s4 = string_strdupz("world unittest");
-        if(s4 == s1) {
-            errors++;
-            fprintf(stderr, "ERROR: string is sharing pointers on different strings\n");
-        }
-        else
-            fprintf(stderr, "OK: string is properly handling different strings\n");
-
-        usec_t start_ut, end_ut;
-        STRING **strings = mallocz(entries * sizeof(STRING *));
-
-        start_ut = now_realtime_usec();
-        for(size_t i = 0; i < entries ;i++) {
-            strings[i] = string_strdupz(names[i]);
-        }
-        end_ut = now_realtime_usec();
-        fprintf(stderr, "Created %zu strings in %llu usecs\n", entries, end_ut - start_ut);
-
-        start_ut = now_realtime_usec();
-        for(size_t i = 0; i < entries ;i++) {
-            strings[i] = string_dup(strings[i]);
-        }
-        end_ut = now_realtime_usec();
-        fprintf(stderr, "Cloned %zu strings in %llu usecs\n", entries, end_ut - start_ut);
-
-        start_ut = now_realtime_usec();
-        for(size_t i = 0; i < entries ;i++) {
-            string_freez(strings[i]);
-            string_freez(strings[i]);
-        }
-        end_ut = now_realtime_usec();
-        fprintf(stderr, "Freed %zu strings in %llu usecs\n", entries, end_ut - start_ut);
-
-        freez(strings);
-
-        if(dictionary_stats_entries(&string_dictionary) != string_entries_starting + 2) {
-            errors++;
-            fprintf(stderr, "ERROR: strings dictionary should have %ld items but it has %ld\n", string_entries_starting + 2, dictionary_stats_entries(&string_dictionary));
-        }
-        else
-            fprintf(stderr, "OK: strings dictionary has 2 items\n");
-    }
-
-    // check 2-way merge
-    {
-        struct testcase {
-            char *src1; char *src2; char *expected;
-        } tests[] = {
-            { "", "", ""},
-            { "a", "", "[x]"},
-            { "", "a", "[x]"},
-            { "a", "a", "a"},
-            { "abcd", "abcd", "abcd"},
-            { "foo_cs", "bar_cs", "[x]_cs"},
-            { "cp_UNIQUE_INFIX_cs", "cp_unique_infix_cs", "cp_[x]_cs"},
-            { "cp_UNIQUE_INFIX_ci_unique_infix_cs", "cp_unique_infix_ci_UNIQUE_INFIX_cs", "cp_[x]_cs"},
-            { "foo[1234]", "foo[4321]", "foo[[x]]"},
-            { NULL, NULL, NULL },
-        };
-
-        for (struct testcase *tc = &tests[0]; tc->expected != NULL; tc++) {
-            STRING *src1 = string_strdupz(tc->src1);
-            STRING *src2 = string_strdupz(tc->src2);
-            STRING *expected = string_strdupz(tc->expected);
-
-            STRING *result = string_2way_merge(src1, src2);
-            if (string_cmp(result, expected) != 0) {
-                fprintf(stderr, "string_2way_merge(\"%s\", \"%s\") -> \"%s\" (expected=\"%s\")\n",
-                        string2str(src1),
-                        string2str(src2),
-                        string2str(result),
-                        string2str(expected));
-                errors++;
-            }
-
-            string_freez(src1);
-            string_freez(src2);
-            string_freez(expected);
-            string_freez(result);
-        }
-    }
-
     dictionary_unittest_free_char_pp(names, entries);
     dictionary_unittest_free_char_pp(values, entries);
 
+    errors += dictionary_unittest_views();
+    errors += dictionary_unittest_threads();
+    errors += dictionary_unittest_view_threads();
+
     fprintf(stderr, "\n%zu errors found\n", errors);
     return  errors ? 1 : 0;
 }
diff --git a/libnetdata/dictionary/dictionary.h b/libnetdata/dictionary/dictionary.h
index fdb2088c0..0e7b3d39f 100644
--- a/libnetdata/dictionary/dictionary.h
+++ b/libnetdata/dictionary/dictionary.h
@@ -13,19 +13,19 @@
  * Names and Values in the dictionary can be cloned or linked.
  * In clone mode, the dictionary does all the memory management.
  * The default is clone for both names and values.
- * Set DICTIONARY_FLAG_NAME_LINK_DONT_CLONE to link names.
- * Set DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE to link names.
+ * Set DICT_OPTION_NAME_LINK_DONT_CLONE to link names.
+ * Set DICT_OPTION_VALUE_LINK_DONT_CLONE to link names.
  *
  * ORDERED
  * Items are ordered in the order they are added (new items are appended at the end).
- * You may reverse the order by setting the flag DICTIONARY_FLAG_ADD_IN_FRONT.
+ * You may reverse the order by setting the flag DICT_OPTION_ADD_IN_FRONT.
  *
  * LOOKUP
  * The dictionary uses JudyHS to maintain a very fast randomly accessible hash table.
  *
  * MULTI-THREADED and SINGLE-THREADED
  * Each dictionary may be single threaded (no locks), or multi-threaded (multiple readers or one writer).
- * The default is multi-threaded. Add the flag DICTIONARY_FLAG_SINGLE_THREADED for single-threaded.
+ * The default is multi-threaded. Add the flag DICT_OPTION_SINGLE_THREADED for single-threaded.
  *
  * WALK-THROUGH and FOREACH traversal
  * The dictionary can be traversed on read or write mode, either with a callback (walkthrough) or with
@@ -35,110 +35,186 @@
  *
  */
 
+#ifdef DICTIONARY_INTERNALS
+#define DICTFE_CONST
+#define DICT_ITEM_CONST
+#else
+#define DICTFE_CONST const
+#define DICT_ITEM_CONST const
+#endif
+
 typedef struct dictionary DICTIONARY;
 typedef struct dictionary_item DICTIONARY_ITEM;
 
-typedef enum dictionary_flags {
-    DICTIONARY_FLAG_NONE                    = 0,        // the default is the opposite of all below
-    DICTIONARY_FLAG_SINGLE_THREADED         = (1 << 0), // don't use any locks (default: use locks)
-    DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE   = (1 << 1), // don't copy the value, just point to the one provided (default: copy)
-    DICTIONARY_FLAG_NAME_LINK_DONT_CLONE    = (1 << 2), // don't copy the name, just point to the one provided (default: copy)
-    DICTIONARY_FLAG_DONT_OVERWRITE_VALUE    = (1 << 3), // don't overwrite values of dictionary items (default: overwrite)
-    DICTIONARY_FLAG_ADD_IN_FRONT            = (1 << 4), // add dictionary items at the front of the linked list (default: at the end)
-
-    // to change the value of the following, you also need to change the corresponding #defines in dictionary.c
-    DICTIONARY_FLAG_RESERVED1               = (1 << 29), // reserved for DICTIONARY_FLAG_EXCLUSIVE_ACCESS
-    DICTIONARY_FLAG_RESERVED2               = (1 << 30), // reserved for DICTIONARY_FLAG_DESTROYED
-    DICTIONARY_FLAG_RESERVED3               = (1 << 31), // reserved for DICTIONARY_FLAG_DEFER_ALL_DELETIONS
-} DICTIONARY_FLAGS;
+typedef enum dictionary_options {
+    DICT_OPTION_NONE                    = 0,        // the default is the opposite of all below
+    DICT_OPTION_SINGLE_THREADED         = (1 << 0), // don't use any locks (default: use locks)
+    DICT_OPTION_VALUE_LINK_DONT_CLONE   = (1 << 1), // don't copy the value, just point to the one provided (default: copy)
+    DICT_OPTION_NAME_LINK_DONT_CLONE    = (1 << 2), // don't copy the name, just point to the one provided (default: copy)
+    DICT_OPTION_DONT_OVERWRITE_VALUE    = (1 << 3), // don't overwrite values of dictionary items (default: overwrite)
+    DICT_OPTION_ADD_IN_FRONT            = (1 << 4), // add dictionary items at the front of the linked list (default: at the end)
+} DICT_OPTIONS;
+
+struct dictionary_stats {
+    const char *name;               // the name of the category
+
+    struct {
+        size_t active;              // the number of active dictionaries
+        size_t deleted;             // the number of dictionaries queued for destruction
+    } dictionaries;
+
+    struct {
+        long entries;               // active items in the dictionary
+        long pending_deletion;      // pending deletion items in the dictionary
+        long referenced;            // referenced items in the dictionary
+    } items;
+
+    struct {
+        size_t creations;           // dictionary creations
+        size_t destructions;        // dictionary destructions
+        size_t flushes;             // dictionary flushes
+        size_t traversals;          // dictionary foreach
+        size_t walkthroughs;        // dictionary walkthrough
+        size_t garbage_collections; // dictionary garbage collections
+        size_t searches;            // item searches
+        size_t inserts;             // item inserts
+        size_t resets;              // item resets
+        size_t deletes;             // item deletes
+    } ops;
+
+    struct {
+        size_t inserts;             // number of times the insert callback is called
+        size_t conflicts;           // number of times the conflict callback is called
+        size_t reacts;              // number of times the react callback is called
+        size_t deletes;             // number of times the delete callback is called
+    } callbacks;
+
+    // memory
+    struct {
+        long indexed;               // bytes of keys indexed (indication of the index size)
+        long values;                // bytes of caller structures
+        long dict;                  // bytes of the structures dictionary needs
+    } memory;
+
+    // spin locks
+    struct {
+        size_t use_spins;           // number of times a reference to item had to spin to acquire it or ignore it
+        size_t search_spins;        // number of times a successful search result had to be thrown away
+        size_t insert_spins;        // number of times an insertion to the hash table had to be repeated
+        size_t delete_spins;        // number of times a deletion had to spin to get a decision
+    } spin_locks;
+};
 
 // Create a dictionary
 #ifdef NETDATA_INTERNAL_CHECKS
-#define dictionary_create(flags) dictionary_create_advanced_with_trace(flags, 0, __FUNCTION__, __LINE__, __FILE__);
-#define dictionary_create_advanced(flags) dictionary_create_advanced_with_trace(flags, 0, __FUNCTION__, __LINE__, __FILE__);
-extern DICTIONARY *dictionary_create_advanced_with_trace(DICTIONARY_FLAGS flags, size_t scratchpad_size, const char *function, size_t line, const char *file);
+#define dictionary_create(options) dictionary_create_advanced_with_trace(options, NULL, __FUNCTION__, __LINE__, __FILE__)
+#define dictionary_create_advanced(options, stats) dictionary_create_advanced_with_trace(options, stats, __FUNCTION__, __LINE__, __FILE__)
+DICTIONARY *dictionary_create_advanced_with_trace(DICT_OPTIONS options, struct dictionary_stats *stats, const char *function, size_t line, const char *file);
 #else
-#define dictionary_create(flags) dictionary_create_advanced(flags, 0);
-extern DICTIONARY *dictionary_create_advanced(DICTIONARY_FLAGS flags, size_t scratchpad_size);
+#define dictionary_create(options) dictionary_create_advanced(options, NULL);
+DICTIONARY *dictionary_create_advanced(DICT_OPTIONS options, struct dictionary_stats *stats);
 #endif
 
-extern void *dictionary_scratchpad(DICTIONARY *dict);
+// Create a view on a dictionary
+#ifdef NETDATA_INTERNAL_CHECKS
+#define dictionary_create_view(master) dictionary_create_view_with_trace(master, __FUNCTION__, __LINE__, __FILE__)
+DICTIONARY *dictionary_create_view_with_trace(DICTIONARY *master, const char *function, size_t line, const char *file);
+#else
+DICTIONARY *dictionary_create_view(DICTIONARY *master);
+#endif
 
 // an insert callback to be called just after an item is added to the dictionary
 // this callback is called while the dictionary is write locked!
-extern void dictionary_register_insert_callback(DICTIONARY *dict, void (*ins_callback)(const char *name, void *value, void *data), void *data);
+void dictionary_register_insert_callback(DICTIONARY *dict, void (*ins_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);
 
 // a delete callback to be called just before an item is deleted forever
 // this callback is called while the dictionary is write locked!
-extern void dictionary_register_delete_callback(DICTIONARY *dict, void (*del_callback)(const char *name, void *value, void *data), void *data);
+void dictionary_register_delete_callback(DICTIONARY *dict, void (*del_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);
 
-// a merge callback to be called when DICTIONARY_FLAG_DONT_OVERWRITE_VALUE
+// a merge callback to be called when DICT_OPTION_DONT_OVERWRITE_VALUE
 // and an item is already found in the dictionary - the dictionary does nothing else in this case
 // the old_value will remain in the dictionary - the new_value is ignored
-extern void dictionary_register_conflict_callback(DICTIONARY *dict, void (*conflict_callback)(const char *name, void *old_value, void *new_value, void *data), void *data);
+// The callback should return true if the value has been updated (it increases the dictionary version).
+void dictionary_register_conflict_callback(DICTIONARY *dict, bool (*conflict_callback)(const DICTIONARY_ITEM *item, void *old_value, void *new_value, void *data), void *data);
 
 // a reaction callback to be called after every item insertion or conflict
 // after the constructors have finished and the items are fully available for use
 // and the dictionary is not write locked anymore
-extern void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)(const char *name, void *value, void *data), void *data);
+void dictionary_register_react_callback(DICTIONARY *dict, void (*react_callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);
 
 // Destroy a dictionary
-// returns the number of bytes freed
-// the returned value will not include name and value sizes if DICTIONARY_FLAG_WITH_STATISTICS is not set
-extern size_t dictionary_destroy(DICTIONARY *dict);
+// Returns the number of bytes freed
+// The returned value will not include name/key sizes
+// Registered delete callbacks will be run for each item in the dictionary.
+size_t dictionary_destroy(DICTIONARY *dict);
 
+// Empties a dictionary
+// Referenced items will survive, but are not offered anymore.
+// Registered delete callbacks will be run for each item in the dictionary.
+void dictionary_flush(DICTIONARY *dict);
+
+void dictionary_version_increment(DICTIONARY *dict);
+
+// ----------------------------------------------------------------------------
 // Set an item in the dictionary
+//
 // - if an item with the same name does not exist, create one
 // - if an item with the same name exists, then:
-//        a) if DICTIONARY_FLAG_DONT_OVERWRITE_VALUE is set, just return the existing value (ignore the new value)
+//        a) if DICT_OPTION_DONT_OVERWRITE_VALUE is set, just return the existing value (ignore the new value)
 //   else b) reset the value to the new value passed at the call
 //
-// When DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE is set, the value is linked, otherwise it is copied
-// When DICTIONARY_FLAG_NAME_LINK_DONT_CLONE is set, the name is linked, otherwise it is copied
+// When DICT_OPTION_VALUE_LINK_DONT_CLONE is set, the value is linked, otherwise it is copied
+// When DICT_OPTION_NAME_LINK_DONT_CLONE is set, the name is linked, otherwise it is copied
 //
-// When neither DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE nor DICTIONARY_FLAG_NAME_LINK_DONT_CLONE are set, all the
+// When neither DICT_OPTION_VALUE_LINK_DONT_CLONE nor DICT_OPTION_NAME_LINK_DONT_CLONE are set, all the
 // memory management for names and values is done by the dictionary.
 //
 // Passing NULL as value, the dictionary will callocz() the newly allocated value, otherwise it will copy it.
 // Passing 0 as value_len, the dictionary will set the value to NULL (no allocations for value will be made).
-extern void *dictionary_set(DICTIONARY *dict, const char *name, void *value, size_t value_len);
+#define dictionary_set(dict, name, value, value_len) dictionary_set_advanced(dict, name, -1, value, value_len, NULL)
+void *dictionary_set_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, void *value, size_t value_len, void *constructor_data);
+
+#define dictionary_set_and_acquire_item(dict, name, value, value_len) dictionary_set_and_acquire_item_advanced(dict, name, -1, value, value_len, NULL)
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_set_and_acquire_item_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, void *value, size_t value_len, void *constructor_data);
 
+// set an item in a dictionary view
+#define dictionary_view_set_and_acquire_item(dict, name, master_item) dictionary_view_set_and_acquire_item_advanced(dict, name, -1, master_item)
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_view_set_and_acquire_item_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, DICTIONARY_ITEM *master_item);
+#define dictionary_view_set(dict, name, master_item) dictionary_view_set_advanced(dict, name, -1, master_item)
+void *dictionary_view_set_advanced(DICTIONARY *dict, const char *name, ssize_t name_len, DICT_ITEM_CONST DICTIONARY_ITEM *master_item);
+
+// ----------------------------------------------------------------------------
 // Get an item from the dictionary
 // If it returns NULL, the item is not found
-extern void *dictionary_get(DICTIONARY *dict, const char *name);
 
+#define dictionary_get(dict, name) dictionary_get_advanced(dict, name, -1)
+void *dictionary_get_advanced(DICTIONARY *dict, const char *name, ssize_t name_len);
+
+#define dictionary_get_and_acquire_item(dict, name) dictionary_get_and_acquire_item_advanced(dict, name, -1)
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_get_and_acquire_item_advanced(DICTIONARY *dict, const char *name, ssize_t name_len);
+
+
+// ----------------------------------------------------------------------------
 // Delete an item from the dictionary
-// returns 0 if the item was found and has been deleted
-// returns -1 if the item was not found in the index
-extern int dictionary_del(DICTIONARY *dict, const char *name);
+// returns true if the item was found and has been deleted
+// returns false if the item was not found in the index
 
-extern DICTIONARY_ITEM *dictionary_get_and_acquire_item_unsafe(DICTIONARY *dict, const char *name);
-extern DICTIONARY_ITEM *dictionary_get_and_acquire_item(DICTIONARY *dict, const char *name);
+#define dictionary_del(dict, name) dictionary_del_advanced(dict, name, -1)
+bool dictionary_del_advanced(DICTIONARY *dict, const char *name, ssize_t name_len);
 
-extern DICTIONARY_ITEM *dictionary_set_and_acquire_item_unsafe(DICTIONARY *dict, const char *name, void *value, size_t value_len);
-extern DICTIONARY_ITEM *dictionary_set_and_acquire_item(DICTIONARY *dict, const char *name, void *value, size_t value_len);
+// ----------------------------------------------------------------------------
+// reference counters management
 
-extern void dictionary_acquired_item_release_unsafe(DICTIONARY *dict, DICTIONARY_ITEM *item);
-extern void dictionary_acquired_item_release(DICTIONARY *dict, DICTIONARY_ITEM *item);
+void dictionary_acquired_item_release(DICTIONARY *dict, DICT_ITEM_CONST DICTIONARY_ITEM *item);
 
-extern DICTIONARY_ITEM *dictionary_acquired_item_dup(DICTIONARY_ITEM *item);
-extern const char *dictionary_acquired_item_name(DICTIONARY_ITEM *item);
-extern void *dictionary_acquired_item_value(DICTIONARY_ITEM *item);
+DICT_ITEM_CONST DICTIONARY_ITEM *dictionary_acquired_item_dup(DICTIONARY *dict, DICT_ITEM_CONST DICTIONARY_ITEM *item);
 
-// UNSAFE functions, without locks
-// to be used when the user is traversing with the right lock type
-// Read lock is acquired by dictionary_walktrhough_read() and dfe_start_read()
-// Write lock is acquired by dictionary_walktrhough_write() and dfe_start_write()
-// For code readability, please use these macros:
-#define dictionary_get_having_read_lock(dict, name) dictionary_get_unsafe(dict, name)
-#define dictionary_get_having_write_lock(dict, name) dictionary_get_unsafe(dict, name)
-#define dictionary_set_having_write_lock(dict, name, value, value_len) dictionary_set_unsafe(dict, name, value, value_len)
-#define dictionary_del_having_write_lock(dict, name) dictionary_del_unsafe(dict, name)
+const char *dictionary_acquired_item_name(DICT_ITEM_CONST DICTIONARY_ITEM *item);
+void *dictionary_acquired_item_value(DICT_ITEM_CONST DICTIONARY_ITEM *item);
 
-extern void *dictionary_get_unsafe(DICTIONARY *dict, const char *name);
-extern void *dictionary_set_unsafe(DICTIONARY *dict, const char *name, void *value, size_t value_len);
-extern int dictionary_del_unsafe(DICTIONARY *dict, const char *name);
+size_t dictionary_acquired_item_references(DICT_ITEM_CONST DICTIONARY_ITEM *item);
 
+// ----------------------------------------------------------------------------
 // Traverse (walk through) the items of the dictionary.
 // The order of traversal is currently the order of insertion.
 //
@@ -153,12 +229,15 @@ extern int dictionary_del_unsafe(DICTIONARY *dict, const char *name);
 //
 #define dictionary_walkthrough_read(dict, callback, data) dictionary_walkthrough_rw(dict, 'r', callback, data)
 #define dictionary_walkthrough_write(dict, callback, data) dictionary_walkthrough_rw(dict, 'w', callback, data)
-extern int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const char *name, void *value, void *data), void *data);
+int dictionary_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *value, void *data), void *data);
 
-#define dictionary_sorted_walkthrough_read(dict, callback, data) dictionary_sorted_walkthrough_rw(dict, 'r', callback, data)
-#define dictionary_sorted_walkthrough_write(dict, callback, data) dictionary_sorted_walkthrough_rw(dict, 'w', callback, data)
-int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const char *name, void *entry, void *data), void *data);
+typedef int (*dictionary_sorted_compar)(const DICTIONARY_ITEM **item1, const DICTIONARY_ITEM **item2);
 
+#define dictionary_sorted_walkthrough_read(dict, callback, data) dictionary_sorted_walkthrough_rw(dict, 'r', callback, data, NULL)
+#define dictionary_sorted_walkthrough_write(dict, callback, data) dictionary_sorted_walkthrough_rw(dict, 'w', callback, data, NULL)
+int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(const DICTIONARY_ITEM *item, void *entry, void *data), void *data, dictionary_sorted_compar compar);
+
+// ----------------------------------------------------------------------------
 // Traverse with foreach
 //
 // Use like this:
@@ -173,80 +252,72 @@ int dictionary_sorted_walkthrough_rw(DICTIONARY *dict, char rw, int (*callback)(
 // You can only delete the current item from inside a dfe_start_write() - you can add as many as you want.
 //
 
-#ifdef DICTIONARY_INTERNALS
-#define DICTFE_CONST
-#else
-#define DICTFE_CONST const
-#endif
+#define DICTIONARY_LOCK_READ      'r'
+#define DICTIONARY_LOCK_WRITE     'w'
+#define DICTIONARY_LOCK_REENTRANT 'z'
 
-#define DICTIONARY_LOCK_READ  'r'
-#define DICTIONARY_LOCK_WRITE 'w'
-#define DICTIONARY_LOCK_NONE  'u'
+void dictionary_write_lock(DICTIONARY *dict);
+void dictionary_write_unlock(DICTIONARY *dict);
 
 typedef DICTFE_CONST struct dictionary_foreach {
+    DICTIONARY *dict;           // the dictionary upon we work
+
+    DICTIONARY_ITEM *item;      // the item we work on, to remember the position we are at
+                                // this can be used with dictionary_acquired_item_dup() to
+                                // acquire the currently working item.
+
     DICTFE_CONST char *name;    // the dictionary name of the last item used
     void *value;                // the dictionary value of the last item used
                                 // same as the return value of dictfe_start() and dictfe_next()
 
-    // the following are for internal use only - to keep track of the point we are
+    size_t counter;             // counts the number of iterations made, starting from zero
+
     char rw;                    // the lock mode 'r' or 'w'
-    usec_t started_ut;          // the time the caller started iterating (now_realtime_usec())
-    DICTIONARY *dict;           // the dictionary upon we work
-    void *last_item;            // the item we work on, to remember the position we are at
 } DICTFE;
 
 #define dfe_start_read(dict, value) dfe_start_rw(dict, value, DICTIONARY_LOCK_READ)
 #define dfe_start_write(dict, value) dfe_start_rw(dict, value, DICTIONARY_LOCK_WRITE)
-#define dfe_start_rw(dict, value, mode) \
-        do { \
-            DICTFE value ## _dfe = {};  \
-            const char *value ## _name; (void)(value ## _name); (void)value; \
-            for((value) = dictionary_foreach_start_rw(&value ## _dfe, (dict), (mode)), ( value ## _name ) = value ## _dfe.name; \
-                (value ## _dfe.name) ;\
-                (value) = dictionary_foreach_next(&value ## _dfe), ( value ## _name ) = value ## _dfe.name) \
+#define dfe_start_reentrant(dict, value) dfe_start_rw(dict, value, DICTIONARY_LOCK_REENTRANT)
+
+#define dfe_start_rw(dict, value, mode)                                                             \
+        do {                                                                                        \
+            DICTFE value ## _dfe = {};                                                              \
+            (void)(value); /* needed to avoid warning when looping without using this */            \
+            for((value) = dictionary_foreach_start_rw(&value ## _dfe, (dict), (mode));              \
+                (value ## _dfe.item) ;                                                              \
+                (value) = dictionary_foreach_next(&value ## _dfe))                                  \
             {
 
-#define dfe_done(value) \
-            }           \
-            dictionary_foreach_done(&value ## _dfe); \
+#define dfe_done(value)                                                                             \
+            }                                                                                       \
+            dictionary_foreach_done(&value ## _dfe);                                                \
         } while(0)
 
-extern void * dictionary_foreach_start_rw(DICTFE *dfe, DICTIONARY *dict, char rw);
-extern void * dictionary_foreach_next(DICTFE *dfe);
-extern usec_t dictionary_foreach_done(DICTFE *dfe);
+void *dictionary_foreach_start_rw(DICTFE *dfe, DICTIONARY *dict, char rw);
+void *dictionary_foreach_next(DICTFE *dfe);
+void  dictionary_foreach_done(DICTFE *dfe);
 
+// ----------------------------------------------------------------------------
 // Get statistics about the dictionary
-extern long int dictionary_stats_allocated_memory(DICTIONARY *dict);
-extern long int dictionary_stats_entries(DICTIONARY *dict);
-extern size_t dictionary_stats_version(DICTIONARY *dict);
-extern size_t dictionary_stats_inserts(DICTIONARY *dict);
-extern size_t dictionary_stats_searches(DICTIONARY *dict);
-extern size_t dictionary_stats_deletes(DICTIONARY *dict);
-extern size_t dictionary_stats_resets(DICTIONARY *dict);
-extern size_t dictionary_stats_walkthroughs(DICTIONARY *dict);
-extern size_t dictionary_stats_referenced_items(DICTIONARY *dict);
-
-extern int dictionary_unittest(size_t entries);
 
-// ----------------------------------------------------------------------------
-// STRING implementation
+size_t dictionary_version(DICTIONARY *dict);
+size_t dictionary_entries(DICTIONARY *dict);
+size_t dictionary_referenced_items(DICTIONARY *dict);
+long int dictionary_stats_for_registry(DICTIONARY *dict);
 
-typedef struct netdata_string STRING;
-extern STRING *string_strdupz(const char *str);
-extern STRING *string_dup(STRING *string);
-extern void string_freez(STRING *string);
-extern size_t string_length(STRING *string);
-extern const char *string2str(STRING *string) NEVERNULL;
+// for all cases that the caller does not provide a stats structure, this is where they are accumulated.
+extern struct dictionary_stats dictionary_stats_category_other;
 
-// keep common prefix/suffix and replace everything else with [x]
-extern STRING *string_2way_merge(STRING *a, STRING *b);
+int dictionary_unittest(size_t entries);
+
+// ----------------------------------------------------------------------------
+// THREAD CACHE
 
-static inline int string_cmp(STRING *s1, STRING *s2) {
-    // STRINGs are deduplicated, so the same strings have the same pointer
-    if(unlikely(s1 == s2)) return 0;
+void *thread_cache_entry_get_or_set(void *key,
+                                    ssize_t key_length,
+                                    void *value,
+                                    void *(*transform_the_value_before_insert)(void *key, size_t key_length, void *value));
 
-    // they differ, do the typical comparison
-    return strcmp(string2str(s1), string2str(s2));
-}
+void thread_cache_destroy(void);
 
 #endif /* NETDATA_DICTIONARY_H */
diff --git a/libnetdata/ebpf/ebpf.c b/libnetdata/ebpf/ebpf.c
index c48f2f24e..382485e5f 100644
--- a/libnetdata/ebpf/ebpf.c
+++ b/libnetdata/ebpf/ebpf.c
@@ -239,7 +239,7 @@ static int kernel_is_rejected()
     }
 
     fclose(kernel_reject_list);
-    freez(reject_string);
+    free(reject_string);
 
     return 0;
 }
@@ -279,7 +279,8 @@ static char *ebpf_select_kernel_name(uint32_t selector)
 {
     static char *kernel_names[] = { NETDATA_IDX_STR_V3_10, NETDATA_IDX_STR_V4_14, NETDATA_IDX_STR_V4_16,
                                     NETDATA_IDX_STR_V4_18, NETDATA_IDX_STR_V5_4,  NETDATA_IDX_STR_V5_10,
-                                    NETDATA_IDX_STR_V5_11, NETDATA_IDX_STR_V5_15, NETDATA_IDX_STR_V5_16
+                                    NETDATA_IDX_STR_V5_11, NETDATA_IDX_STR_V5_14, NETDATA_IDX_STR_V5_15,
+                                    NETDATA_IDX_STR_V5_16
                                   };
 
     return kernel_names[selector];
@@ -298,7 +299,11 @@ static char *ebpf_select_kernel_name(uint32_t selector)
 static int ebpf_select_max_index(int is_rhf, uint32_t kver)
 {
     if (is_rhf > 0) { // Is Red Hat family
-        if (kver >= NETDATA_EBPF_KERNEL_4_11)
+        if (kver >= NETDATA_EBPF_KERNEL_5_14)
+            return NETDATA_IDX_V5_14;
+        else if (kver >= NETDATA_EBPF_KERNEL_5_4 && kver < NETDATA_EBPF_KERNEL_5_5) // For Oracle Linux
+            return NETDATA_IDX_V5_4;
+        else if (kver >= NETDATA_EBPF_KERNEL_4_11)
             return NETDATA_IDX_V4_18;
     } else { // Kernels from kernel.org
         if (kver >= NETDATA_EBPF_KERNEL_5_16)
@@ -334,6 +339,9 @@ static uint32_t ebpf_select_index(uint32_t kernels, int is_rhf, uint32_t kver)
     uint32_t start = ebpf_select_max_index(is_rhf, kver);
     uint32_t idx;
 
+    if (is_rhf == -1)
+        kernels &= ~NETDATA_V5_14;
+
     for (idx = start; idx; idx--) {
         if (kernels & 1 << idx)
             break;
@@ -438,9 +446,9 @@ void ebpf_update_stats(ebpf_plugin_stats_t *report, ebpf_module_t *em)
 
     // In theory the `else if` is useless, because when this function is called, the module should not stay in
     // EBPF_LOAD_PLAY_DICE. We have this additional condition to detect errors from developers.
-    if (em->load == EBPF_LOAD_LEGACY)
+    if (em->load & EBPF_LOAD_LEGACY)
         report->legacy++;
-    else if (em->load == EBPF_LOAD_CORE)
+    else if (em->load & EBPF_LOAD_CORE)
         report->core++;
 
     ebpf_stats_targets(report, em->targets);
@@ -463,26 +471,42 @@ void ebpf_update_pid_table(ebpf_local_maps_t *pid, ebpf_module_t *em)
  * @param em        the structure with information about how the module/thread is working.
  * @param map_name  the name of the file used to log.
  */
-void ebpf_update_map_size(struct bpf_map *map, ebpf_local_maps_t *lmap, ebpf_module_t *em, const char *map_name)
+void ebpf_update_map_size(struct bpf_map *map, ebpf_local_maps_t *lmap, ebpf_module_t *em, const char *map_name __maybe_unused)
 {
+    uint32_t define_size = 0;
     uint32_t apps_type = NETDATA_EBPF_MAP_PID | NETDATA_EBPF_MAP_RESIZABLE;
     if (lmap->user_input && lmap->user_input != lmap->internal_input) {
+        define_size = lmap->internal_input;
 #ifdef NETDATA_INTERNAL_CHECKS
         info("Changing map %s from size %u to %u ", map_name, lmap->internal_input, lmap->user_input);
 #endif
-#ifdef LIBBPF_MAJOR_VERSION
-        bpf_map__set_max_entries(map, lmap->user_input);
-#else
-        bpf_map__resize(map, lmap->user_input);
-#endif
     } else if (((lmap->type & apps_type) == apps_type) && (!em->apps_charts) && (!em->cgroup_charts)) {
         lmap->user_input = ND_EBPF_DEFAULT_MIN_PID;
+    } else if (((em->apps_charts) || (em->cgroup_charts)) && (em->apps_level != NETDATA_APPS_NOT_SET)) {
+        switch (em->apps_level) {
+            case NETDATA_APPS_LEVEL_ALL: {
+                define_size = lmap->user_input;
+                break;
+            }
+            case NETDATA_APPS_LEVEL_PARENT: {
+                define_size = ND_EBPF_DEFAULT_PID_SIZE / 2;
+                break;
+            }
+            case NETDATA_APPS_LEVEL_REAL_PARENT:
+            default: {
+                define_size = ND_EBPF_DEFAULT_PID_SIZE / 3;
+            }
+        }
+    }
+
+    if (!define_size)
+        return;
+
 #ifdef LIBBPF_MAJOR_VERSION
-        bpf_map__set_max_entries(map, lmap->user_input);
+    bpf_map__set_max_entries(map, define_size);
 #else
-        bpf_map__resize(map, lmap->user_input);
+    bpf_map__resize(map, define_size);
 #endif
-    }
 }
 
 /**
@@ -607,11 +631,18 @@ static void ebpf_update_maps(ebpf_module_t *em, struct bpf_object *obj)
  */
 void ebpf_update_controller(int fd, ebpf_module_t *em)
 {
-    uint32_t key = NETDATA_CONTROLLER_APPS_ENABLED;
-    uint32_t value = (em->apps_charts & NETDATA_EBPF_APPS_FLAG_YES) | em->cgroup_charts;
-    int ret = bpf_map_update_elem(fd, &key, &value, 0);
-    if (ret)
-        error("Add key(%u) for controller table failed.", key);
+    uint32_t values[NETDATA_CONTROLLER_END] = {
+        (em->apps_charts & NETDATA_EBPF_APPS_FLAG_YES) | em->cgroup_charts,
+        em->apps_level
+    };
+    uint32_t key;
+    uint32_t end = (em->apps_level != NETDATA_APPS_NOT_SET) ? NETDATA_CONTROLLER_END : NETDATA_CONTROLLER_APPS_LEVEL;
+
+    for (key = NETDATA_CONTROLLER_APPS_ENABLED; key < end; key++) {
+        int ret = bpf_map_update_elem(fd, &key, &values[key], 0);
+        if (ret)
+            error("Add key(%u) for controller table failed.", key);
+    }
 }
 
 /**
@@ -667,6 +698,10 @@ struct bpf_link **ebpf_load_program(char *plugins_dir, ebpf_module_t *em, int kv
 
     ebpf_mount_name(lpath, 4095, plugins_dir, idx, em->thread_name, em->mode);
 
+    // When this function is called ebpf.plugin is using legacy code, so we should reset the variable
+    em->load &= ~ NETDATA_EBPF_LOAD_METHODS;
+    em->load |= EBPF_LOAD_LEGACY;
+
     *obj = bpf_object__open_file(lpath, NULL);
     if (libbpf_get_error(obj)) {
         error("Cannot open BPF object %s", lpath);
@@ -797,15 +832,53 @@ netdata_ebpf_load_mode_t epbf_convert_string_to_load_mode(char *str)
  */
 static char *ebpf_convert_load_mode_to_string(netdata_ebpf_load_mode_t mode)
 {
-    if (mode == EBPF_LOAD_CORE)
+    if (mode & EBPF_LOAD_CORE)
         return EBPF_CFG_CORE_PROGRAM;
-    else if (mode == EBPF_LOAD_LEGACY)
+    else if (mode & EBPF_LOAD_LEGACY)
         return EBPF_CFG_LEGACY_PROGRAM;
 
     return EBPF_CFG_DEFAULT_PROGRAM;
 }
 
 /**
+ * Convert collect pid to string
+ *
+ * @param level value that will select the string
+ *
+ * @return It returns the string associated to level.
+ */
+static char *ebpf_convert_collect_pid_to_string(netdata_apps_level_t level)
+{
+    if (level == NETDATA_APPS_LEVEL_REAL_PARENT)
+        return EBPF_CFG_PID_REAL_PARENT;
+    else if (level == NETDATA_APPS_LEVEL_PARENT)
+        return EBPF_CFG_PID_PARENT;
+    else if (level == NETDATA_APPS_LEVEL_ALL)
+        return EBPF_CFG_PID_ALL;
+
+    return EBPF_CFG_PID_INTERNAL_USAGE;
+}
+
+/**
+ * Convert string to apps level
+ *
+ * @param str the argument read from config files
+ *
+ * @return it returns the level associated to the string or default when it is a wrong value
+ */
+netdata_apps_level_t ebpf_convert_string_to_apps_level(char *str)
+{
+    if (!strcasecmp(str, EBPF_CFG_PID_REAL_PARENT))
+        return NETDATA_APPS_LEVEL_REAL_PARENT;
+    else if (!strcasecmp(str, EBPF_CFG_PID_PARENT))
+        return NETDATA_APPS_LEVEL_PARENT;
+    else if (!strcasecmp(str, EBPF_CFG_PID_ALL))
+        return NETDATA_APPS_LEVEL_ALL;
+
+    return NETDATA_APPS_NOT_SET;
+}
+
+/**
  *  CO-RE type
  *
  *  Select the preferential type of CO-RE
@@ -836,9 +909,11 @@ netdata_ebpf_program_loaded_t ebpf_convert_core_type(char *str, netdata_run_mode
 void ebpf_adjust_thread_load(ebpf_module_t *mod, struct btf *file)
 {
     if (!file) {
-        mod->load = EBPF_LOAD_LEGACY;
+        mod->load &= ~EBPF_LOAD_CORE;
+        mod->load |= EBPF_LOAD_LEGACY;
     } else if (mod->load == EBPF_LOAD_PLAY_DICE && file) {
-        mod->load = EBPF_LOAD_CORE;
+        mod->load &= ~EBPF_LOAD_LEGACY;
+        mod->load |= EBPF_LOAD_CORE;
     }
 }
 
@@ -952,13 +1027,45 @@ static void ebpf_update_target_with_conf(ebpf_module_t *em, netdata_ebpf_program
 }
 
 /**
+ * Select Load Mode
+ *
+ * Select the load mode according the given inputs.
+ *
+ * @param btf_file a pointer to the loaded btf file.
+ * @parma load     current value.
+ * @param btf_file a pointer to the loaded btf file.
+ * @param is_rhf is Red Hat family?
+ *
+ * @return it returns the new load mode.
+ */
+static netdata_ebpf_load_mode_t ebpf_select_load_mode(struct btf *btf_file, netdata_ebpf_load_mode_t load,
+                                                      int kver, int is_rh)
+{
+#ifdef LIBBPF_MAJOR_VERSION
+    if ((load & EBPF_LOAD_CORE) || (load & EBPF_LOAD_PLAY_DICE)) {
+        // Quick fix for Oracle linux 8.x
+        load = (!btf_file || (is_rh && (kver >= NETDATA_EBPF_KERNEL_5_4 && kver < NETDATA_EBPF_KERNEL_5_5))) ?
+               EBPF_LOAD_LEGACY : EBPF_LOAD_CORE;
+    }
+#else
+    load = EBPF_LOAD_LEGACY;
+#endif
+
+    return load;
+}
+
+/**
  * Update Module using config
  *
  * Update configuration for a specific thread.
  *
  * @param modules   structure that will be updated
+ * @oaram origin    specify the configuration file loaded
+ * @param btf_file a pointer to the loaded btf file.
+ * @param is_rhf is Red Hat family?
  */
-void ebpf_update_module_using_config(ebpf_module_t *modules)
+void ebpf_update_module_using_config(ebpf_module_t *modules, netdata_ebpf_load_mode_t origin, struct btf *btf_file,
+                                     int kver, int is_rh)
 {
     char default_value[EBPF_MAX_MODE_LENGTH + 1];
     ebpf_select_mode_string(default_value, EBPF_MAX_MODE_LENGTH, modules->mode);
@@ -977,13 +1084,19 @@ void ebpf_update_module_using_config(ebpf_module_t *modules)
     modules->pid_map_size = (uint32_t)appconfig_get_number(modules->cfg, EBPF_GLOBAL_SECTION, EBPF_CFG_PID_SIZE,
                                                            modules->pid_map_size);
 
-    value = ebpf_convert_load_mode_to_string(modules->load);
+    value = ebpf_convert_load_mode_to_string(modules->load & NETDATA_EBPF_LOAD_METHODS);
     value = appconfig_get(modules->cfg, EBPF_GLOBAL_SECTION, EBPF_CFG_TYPE_FORMAT, value);
-    modules->load = epbf_convert_string_to_load_mode(value);
+    netdata_ebpf_load_mode_t load = epbf_convert_string_to_load_mode(value);
+    load = ebpf_select_load_mode(btf_file, load, kver, is_rh);
+    modules->load = origin | load;
 
     value = appconfig_get(modules->cfg, EBPF_GLOBAL_SECTION, EBPF_CFG_CORE_ATTACH, EBPF_CFG_ATTACH_TRAMPOLINE);
     netdata_ebpf_program_loaded_t fill_lm = ebpf_convert_core_type(value, modules->mode);
     ebpf_update_target_with_conf(modules, fill_lm);
+
+    value = ebpf_convert_collect_pid_to_string(modules->apps_level);
+    value = appconfig_get(modules->cfg, EBPF_GLOBAL_SECTION, EBPF_CFG_COLLECT_PID, value);
+    modules->apps_level =  ebpf_convert_string_to_apps_level(value);
 }
 
 /**
@@ -995,10 +1108,15 @@ void ebpf_update_module_using_config(ebpf_module_t *modules)
  * update the variables.
  *
  * @param em       the module structure
+ * @param btf_file a pointer to the loaded btf file.
+ * @param is_rhf is Red Hat family?
+ * @param kver   the kernel version
  */
-void ebpf_update_module(ebpf_module_t *em)
+void ebpf_update_module(ebpf_module_t *em, struct btf *btf_file, int kver, int is_rh)
 {
     char filename[FILENAME_MAX+1];
+    netdata_ebpf_load_mode_t origin;
+
     ebpf_mount_config_name(filename, FILENAME_MAX, ebpf_user_config_dir, em->config_file);
     if (!ebpf_load_config(em->cfg, filename)) {
         ebpf_mount_config_name(filename, FILENAME_MAX, ebpf_stock_config_dir, em->config_file);
@@ -1006,9 +1124,32 @@ void ebpf_update_module(ebpf_module_t *em)
             error("Cannot load the ebpf configuration file %s", em->config_file);
             return;
         }
-    }
+        // If user defined data globaly, we will have here EBPF_LOADED_FROM_USER, we need to consider this, to avoid
+        // forcing users to configure thread by thread.
+        origin = (!(em->load & NETDATA_EBPF_LOAD_SOURCE)) ? EBPF_LOADED_FROM_STOCK : em->load & NETDATA_EBPF_LOAD_SOURCE;
+    } else
+        origin = EBPF_LOADED_FROM_USER;
 
-    ebpf_update_module_using_config(em);
+    ebpf_update_module_using_config(em, origin, btf_file, kver, is_rh);
+}
+
+/**
+ * Adjust Apps Cgroup
+ *
+ * Apps and cgroup has internal cleanup that needs attaching tracers to release_task, to avoid overload the function
+ * we will enable this integration by default, if and only if, we are running with trampolines.
+ *
+ * @param em   a poiter to the main thread structure.
+ * @param mode is the mode used with different
+ */
+void ebpf_adjust_apps_cgroup(ebpf_module_t *em, netdata_ebpf_program_loaded_t mode)
+{
+    if ((em->load & EBPF_LOADED_FROM_STOCK) &&
+    (em->apps_charts || em->cgroup_charts) &&
+    mode != EBPF_LOAD_TRAMPOLINE) {
+        em->apps_charts = NETDATA_EBPF_APPS_FLAG_NO;
+        em->cgroup_charts = 0;
+    }
 }
 
 //----------------------------------------------------------------------------------------------------------------------
@@ -1282,4 +1423,5 @@ void ebpf_select_host_prefix(char *output, size_t length, char *syscall, int kve
         char *prefix = (arch == 32) ? "__ia32" : "__x64";
         snprintfz(output, length, "%s_sys_%s", prefix, syscall);
     }
-}
\ No newline at end of file
+}
+
diff --git a/libnetdata/ebpf/ebpf.h b/libnetdata/ebpf/ebpf.h
index 55b68a51e..5cff5134f 100644
--- a/libnetdata/ebpf/ebpf.h
+++ b/libnetdata/ebpf/ebpf.h
@@ -26,6 +26,12 @@
 #define EBPF_CFG_CORE_PROGRAM "CO-RE"
 #define EBPF_CFG_LEGACY_PROGRAM "legacy"
 
+#define EBPF_CFG_COLLECT_PID "collect pid"
+#define EBPF_CFG_PID_REAL_PARENT "real parent"
+#define EBPF_CFG_PID_PARENT "parent"
+#define EBPF_CFG_PID_ALL "all"
+#define EBPF_CFG_PID_INTERNAL_USAGE "not used"
+
 #define EBPF_CFG_CORE_ATTACH "ebpf co-re tracing"
 #define EBPF_CFG_ATTACH_TRAMPOLINE "trampoline"
 #define EBPF_CFG_ATTACH_TRACEPOINT "tracepoint"
@@ -71,11 +77,15 @@
  */
 enum netdata_ebpf_kernel_versions {
     NETDATA_EBPF_KERNEL_4_11 = 264960,  //  264960 = 4 * 65536 + 15 * 256
+    NETDATA_EBPF_KERNEL_4_14 = 265728,  //  264960 = 4 * 65536 + 14 * 256
     NETDATA_EBPF_KERNEL_4_15 = 265984,  //  265984 = 4 * 65536 + 15 * 256
     NETDATA_EBPF_KERNEL_4_17 = 266496,  //  266496 = 4 * 65536 + 17 * 256
     NETDATA_EBPF_KERNEL_5_0  = 327680,  //  327680 = 5 * 65536 +  0 * 256
+    NETDATA_EBPF_KERNEL_5_4  = 328704,  //  327680 = 5 * 65536 +  4 * 256
+    NETDATA_EBPF_KERNEL_5_5  = 328960,  //  327680 = 5 * 65536 +  5 * 256
     NETDATA_EBPF_KERNEL_5_10 = 330240,  //  330240 = 5 * 65536 + 10 * 256
     NETDATA_EBPF_KERNEL_5_11 = 330496,  //  330240 = 5 * 65536 + 11 * 256
+    NETDATA_EBPF_KERNEL_5_14 = 331264,  //  331264 = 5 * 65536 + 14 * 256
     NETDATA_EBPF_KERNEL_5_15 = 331520,  //  331520 = 5 * 65536 + 15 * 256
     NETDATA_EBPF_KERNEL_5_16 = 331776   //  331776 = 5 * 65536 + 16 * 256
 };
@@ -88,8 +98,9 @@ enum netdata_kernel_flag {
     NETDATA_V5_4  = 1 << 4,
     NETDATA_V5_10 = 1 << 5,
     NETDATA_V5_11 = 1 << 6,
-    NETDATA_V5_15 = 1 << 7,
-    NETDATA_V5_16 = 1 << 8
+    NETDATA_V5_14 = 1 << 7,
+    NETDATA_V5_15 = 1 << 8,
+    NETDATA_V5_16 = 1 << 9
 };
 
 enum netdata_kernel_idx {
@@ -100,6 +111,7 @@ enum netdata_kernel_idx {
     NETDATA_IDX_V5_4 ,
     NETDATA_IDX_V5_10,
     NETDATA_IDX_V5_11,
+    NETDATA_IDX_V5_14,
     NETDATA_IDX_V5_15,
     NETDATA_IDX_V5_16
 };
@@ -111,6 +123,7 @@ enum netdata_kernel_idx {
 #define NETDATA_IDX_STR_V5_4  "5.4"
 #define NETDATA_IDX_STR_V5_10 "5.10"
 #define NETDATA_IDX_STR_V5_11 "5.11"
+#define NETDATA_IDX_STR_V5_14 "5.14"
 #define NETDATA_IDX_STR_V5_15 "5.15"
 #define NETDATA_IDX_STR_V5_16 "5.16"
 
@@ -161,10 +174,21 @@ enum netdata_ebpf_map_type {
 
 enum netdata_controller {
     NETDATA_CONTROLLER_APPS_ENABLED,
+    NETDATA_CONTROLLER_APPS_LEVEL,
 
     NETDATA_CONTROLLER_END
 };
 
+// Control how Netdata will monitor PIDs (apps and cgroups)
+typedef enum netdata_apps_level {
+    NETDATA_APPS_LEVEL_REAL_PARENT,
+    NETDATA_APPS_LEVEL_PARENT,
+    NETDATA_APPS_LEVEL_ALL,
+
+    // Present only in user ring
+    NETDATA_APPS_NOT_SET
+} netdata_apps_level_t;
+
 typedef struct ebpf_local_maps {
     char *name;
     uint32_t internal_input;
@@ -181,11 +205,14 @@ typedef struct ebpf_specify_name {
 } ebpf_specify_name_t;
 
 typedef enum netdata_ebpf_load_mode {
-    EBPF_LOAD_LEGACY,        // Select legacy mode, this means we will load binaries
-    EBPF_LOAD_CORE,          // When CO-RE is used, it is necessary to use the souce code
-
-    EBPF_LOAD_PLAY_DICE      // Take a look on environment and choose the best option
+    EBPF_LOAD_LEGACY = 1<<0,        // Select legacy mode, this means we will load binaries
+    EBPF_LOAD_CORE = 1<<1,          // When CO-RE is used, it is necessary to use the souce code
+    EBPF_LOAD_PLAY_DICE = 1<<2,      // Take a look on environment and choose the best option
+    EBPF_LOADED_FROM_STOCK = 1<<3,  // Configuration loaded from Stock file
+    EBPF_LOADED_FROM_USER = 1<<4    // Configuration loaded from user
 } netdata_ebpf_load_mode_t;
+#define NETDATA_EBPF_LOAD_METHODS (EBPF_LOAD_LEGACY|EBPF_LOAD_CORE|EBPF_LOAD_PLAY_DICE)
+#define NETDATA_EBPF_LOAD_SOURCE (EBPF_LOADED_FROM_STOCK|EBPF_LOADED_FROM_USER)
 
 typedef enum netdata_ebpf_program_loaded {
     EBPF_LOAD_PROBE,         // Attach probes on targets
@@ -227,6 +254,7 @@ typedef struct ebpf_module {
     int update_every;
     int global_charts;
     netdata_apps_integration_flags_t apps_charts;
+    netdata_apps_level_t apps_level;
     int cgroup_charts;
     netdata_run_mode_t mode;
     uint32_t thread_id;
@@ -242,26 +270,28 @@ typedef struct ebpf_module {
     netdata_ebpf_targets_t *targets;
     struct bpf_link **probe_links;
     struct bpf_object *objects;
+    struct netdata_static_thread *thread;
 } ebpf_module_t;
 
-extern int ebpf_get_kernel_version();
-extern int get_redhat_release();
-extern int has_condition_to_run(int version);
-extern char *ebpf_kernel_suffix(int version, int isrh);
-extern struct bpf_link **ebpf_load_program(char *plugins_dir, ebpf_module_t *em, int kver, int is_rhf,
+int ebpf_get_kernel_version();
+int get_redhat_release();
+int has_condition_to_run(int version);
+char *ebpf_kernel_suffix(int version, int isrh);
+struct bpf_link **ebpf_load_program(char *plugins_dir, ebpf_module_t *em, int kver, int is_rhf,
                                            struct bpf_object **obj);
 
-extern void ebpf_mount_config_name(char *filename, size_t length, char *path, const char *config);
-extern int ebpf_load_config(struct config *config, char *filename);
-extern void ebpf_update_module(ebpf_module_t *em);
-extern void ebpf_update_names(ebpf_specify_name_t *opt, ebpf_module_t *em);
-extern char *ebpf_find_symbol(char *search);
-extern void ebpf_load_addresses(ebpf_addresses_t *fa, int fd);
-extern void ebpf_fill_algorithms(int *algorithms, size_t length, int algorithm);
-extern char **ebpf_fill_histogram_dimension(size_t maximum);
-extern void ebpf_update_stats(ebpf_plugin_stats_t *report, ebpf_module_t *em);
-extern void ebpf_update_controller(int fd, ebpf_module_t *em);
-extern void ebpf_update_map_size(struct bpf_map *map, ebpf_local_maps_t *lmap, ebpf_module_t *em, const char *map_name);
+void ebpf_mount_config_name(char *filename, size_t length, char *path, const char *config);
+int ebpf_load_config(struct config *config, char *filename);
+void ebpf_update_module(ebpf_module_t *em, struct btf *btf_file, int kver, int is_rh);
+void ebpf_update_names(ebpf_specify_name_t *opt, ebpf_module_t *em);
+void ebpf_adjust_apps_cgroup(ebpf_module_t *em, netdata_ebpf_program_loaded_t mode);
+char *ebpf_find_symbol(char *search);
+void ebpf_load_addresses(ebpf_addresses_t *fa, int fd);
+void ebpf_fill_algorithms(int *algorithms, size_t length, int algorithm);
+char **ebpf_fill_histogram_dimension(size_t maximum);
+void ebpf_update_stats(ebpf_plugin_stats_t *report, ebpf_module_t *em);
+void ebpf_update_controller(int fd, ebpf_module_t *em);
+void ebpf_update_map_size(struct bpf_map *map, ebpf_local_maps_t *lmap, ebpf_module_t *em, const char *map_name);
 
 // Histogram
 #define NETDATA_EBPF_HIST_MAX_BINS 24UL
@@ -312,13 +342,13 @@ typedef struct ebpf_sync_syscalls {
 #endif
 } ebpf_sync_syscalls_t;
 
-extern void ebpf_histogram_dimension_cleanup(char **ptr, size_t length);
+void ebpf_histogram_dimension_cleanup(char **ptr, size_t length);
 
 // Tracepoint helpers
 // For more information related to tracepoints read https://www.kernel.org/doc/html/latest/trace/tracepoints.html
-extern int ebpf_is_tracepoint_enabled(char *subsys, char *eventname);
-extern int ebpf_enable_tracing_values(char *subsys, char *eventname);
-extern int ebpf_disable_tracing_values(char *subsys, char *eventname);
+int ebpf_is_tracepoint_enabled(char *subsys, char *eventname);
+int ebpf_enable_tracing_values(char *subsys, char *eventname);
+int ebpf_disable_tracing_values(char *subsys, char *eventname);
 
 // BTF Section
 #define EBPF_DEFAULT_BTF_FILE "vmlinux"
@@ -328,14 +358,14 @@ extern int ebpf_disable_tracing_values(char *subsys, char *eventname);
 // BTF helpers
 #define NETDATA_EBPF_MAX_SYSCALL_LENGTH 255
 
-extern netdata_ebpf_load_mode_t epbf_convert_string_to_load_mode(char *str);
-extern netdata_ebpf_program_loaded_t ebpf_convert_core_type(char *str, netdata_run_mode_t lmode);
-extern void ebpf_select_host_prefix(char *output, size_t length, char *syscall, int kver);
+netdata_ebpf_load_mode_t epbf_convert_string_to_load_mode(char *str);
+netdata_ebpf_program_loaded_t ebpf_convert_core_type(char *str, netdata_run_mode_t lmode);
+void ebpf_select_host_prefix(char *output, size_t length, char *syscall, int kver);
 #ifdef LIBBPF_MAJOR_VERSION
-extern void ebpf_adjust_thread_load(ebpf_module_t *mod, struct btf *file);
-extern struct btf *ebpf_parse_btf_file(const char *filename);
-extern struct btf *ebpf_load_btf_file(char *path, char *filename);
-extern int ebpf_is_function_inside_btf(struct btf *file, char *function);
+void ebpf_adjust_thread_load(ebpf_module_t *mod, struct btf *file);
+struct btf *ebpf_parse_btf_file(const char *filename);
+struct btf *ebpf_load_btf_file(char *path, char *filename);
+int ebpf_is_function_inside_btf(struct btf *file, char *function);
 #endif
 
 #endif /* NETDATA_EBPF_H */
diff --git a/libnetdata/eval/eval.c b/libnetdata/eval/eval.c
index e86cbd587..0e429a08c 100644
--- a/libnetdata/eval/eval.c
+++ b/libnetdata/eval/eval.c
@@ -62,24 +62,36 @@ static inline void print_parsed_as_constant(BUFFER *out, NETDATA_DOUBLE n);
 // evaluation of expressions
 
 static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *v, int *error) {
-    static uint32_t this_hash = 0, now_hash = 0, after_hash = 0, before_hash = 0, status_hash = 0, removed_hash = 0, uninitialized_hash = 0, undefined_hash = 0, clear_hash = 0, warning_hash = 0, critical_hash = 0;
+    static STRING
+        *this_string = NULL,
+        *now_string = NULL,
+        *after_string = NULL,
+        *before_string = NULL,
+        *status_string = NULL,
+        *removed_string = NULL,
+        *uninitialized_string = NULL,
+        *undefined_string = NULL,
+        *clear_string = NULL,
+        *warning_string = NULL,
+        *critical_string = NULL;
+
     NETDATA_DOUBLE n;
 
-    if(unlikely(this_hash == 0)) {
-        this_hash = simple_hash("this");
-        now_hash = simple_hash("now");
-        after_hash = simple_hash("after");
-        before_hash = simple_hash("before");
-        status_hash = simple_hash("status");
-        removed_hash = simple_hash("REMOVED");
-        uninitialized_hash = simple_hash("UNINITIALIZED");
-        undefined_hash = simple_hash("UNDEFINED");
-        clear_hash = simple_hash("CLEAR");
-        warning_hash = simple_hash("WARNING");
-        critical_hash = simple_hash("CRITICAL");
-    }
-
-    if(unlikely(v->hash == this_hash && !strcmp(v->name, "this"))) {
+    if(unlikely(this_string == NULL)) {
+        this_string = string_strdupz("this");
+        now_string = string_strdupz("now");
+        after_string = string_strdupz("after");
+        before_string = string_strdupz("before");
+        status_string = string_strdupz("status");
+        removed_string = string_strdupz("REMOVED");
+        uninitialized_string = string_strdupz("UNINITIALIZED");
+        undefined_string = string_strdupz("UNDEFINED");
+        clear_string = string_strdupz("CLEAR");
+        warning_string = string_strdupz("WARNING");
+        critical_string = string_strdupz("CRITICAL");
+    }
+
+    if(unlikely(v->name == this_string)) {
         n = (exp->myself)?*exp->myself:NAN;
         buffer_strcat(exp->error_msg, "[ $this = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -87,7 +99,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == after_hash && !strcmp(v->name, "after"))) {
+    if(unlikely(v->name == after_string)) {
         n = (exp->after && *exp->after)?*exp->after:NAN;
         buffer_strcat(exp->error_msg, "[ $after = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -95,7 +107,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == before_hash && !strcmp(v->name, "before"))) {
+    if(unlikely(v->name == before_string)) {
         n = (exp->before && *exp->before)?*exp->before:NAN;
         buffer_strcat(exp->error_msg, "[ $before = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -103,15 +115,15 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == now_hash && !strcmp(v->name, "now"))) {
-        n = now_realtime_sec();
+    if(unlikely(v->name == now_string)) {
+        n = (NETDATA_DOUBLE)now_realtime_sec();
         buffer_strcat(exp->error_msg, "[ $now = ");
         print_parsed_as_constant(exp->error_msg, n);
         buffer_strcat(exp->error_msg, " ] ");
         return n;
     }
 
-    if(unlikely(v->hash == status_hash && !strcmp(v->name, "status"))) {
+    if(unlikely(v->name == status_string)) {
         n = (exp->status)?*exp->status:RRDCALC_STATUS_UNINITIALIZED;
         buffer_strcat(exp->error_msg, "[ $status = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -119,7 +131,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == removed_hash && !strcmp(v->name, "REMOVED"))) {
+    if(unlikely(v->name == removed_string)) {
         n = RRDCALC_STATUS_REMOVED;
         buffer_strcat(exp->error_msg, "[ $REMOVED = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -127,7 +139,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == uninitialized_hash && !strcmp(v->name, "UNINITIALIZED"))) {
+    if(unlikely(v->name == uninitialized_string)) {
         n = RRDCALC_STATUS_UNINITIALIZED;
         buffer_strcat(exp->error_msg, "[ $UNINITIALIZED = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -135,7 +147,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == undefined_hash && !strcmp(v->name, "UNDEFINED"))) {
+    if(unlikely(v->name == undefined_string)) {
         n = RRDCALC_STATUS_UNDEFINED;
         buffer_strcat(exp->error_msg, "[ $UNDEFINED = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -143,7 +155,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == clear_hash && !strcmp(v->name, "CLEAR"))) {
+    if(unlikely(v->name == clear_string)) {
         n = RRDCALC_STATUS_CLEAR;
         buffer_strcat(exp->error_msg, "[ $CLEAR = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -151,7 +163,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == warning_hash && !strcmp(v->name, "WARNING"))) {
+    if(unlikely(v->name == warning_string)) {
         n = RRDCALC_STATUS_WARNING;
         buffer_strcat(exp->error_msg, "[ $WARNING = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -159,7 +171,7 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(unlikely(v->hash == critical_hash && !strcmp(v->name, "CRITICAL"))) {
+    if(unlikely(v->name == critical_string)) {
         n = RRDCALC_STATUS_CRITICAL;
         buffer_strcat(exp->error_msg, "[ $CRITICAL = ");
         print_parsed_as_constant(exp->error_msg, n);
@@ -167,15 +179,15 @@ static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *
         return n;
     }
 
-    if(exp->rrdcalc && health_variable_lookup(v->name, v->hash, exp->rrdcalc, &n)) {
-        buffer_sprintf(exp->error_msg, "[ ${%s} = ", v->name);
+    if(exp->rrdcalc && health_variable_lookup(v->name, exp->rrdcalc, &n)) {
+        buffer_sprintf(exp->error_msg, "[ ${%s} = ", string2str(v->name));
         print_parsed_as_constant(exp->error_msg, n);
         buffer_strcat(exp->error_msg, " ] ");
         return n;
     }
 
     *error = EVAL_ERROR_UNKNOWN_VARIABLE;
-    buffer_sprintf(exp->error_msg, "[ undefined variable '%s' ] ", v->name);
+    buffer_sprintf(exp->error_msg, "[ undefined variable '%s' ] ", string2str(v->name));
     return NAN;
 }
 
@@ -357,7 +369,7 @@ static inline NETDATA_DOUBLE eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int
 
 static inline void print_parsed_as_variable(BUFFER *out, EVAL_VARIABLE *v, int *error) {
     (void)error;
-    buffer_sprintf(out, "${%s}", v->name);
+    buffer_sprintf(out, "${%s}", string2str(v->name));
 }
 
 static inline void print_parsed_as_constant(BUFFER *out, NETDATA_DOUBLE n) {
@@ -859,12 +871,11 @@ static inline void eval_node_set_value_to_variable(EVAL_NODE *op, int pos, const
 
     op->ops[pos].type = EVAL_VALUE_VARIABLE;
     op->ops[pos].variable = callocz(1, sizeof(EVAL_VARIABLE));
-    op->ops[pos].variable->name = strdupz(variable);
-    op->ops[pos].variable->hash = simple_hash(op->ops[pos].variable->name);
+    op->ops[pos].variable->name = string_strdupz(variable);
 }
 
 static inline void eval_variable_free(EVAL_VARIABLE *v) {
-    freez(v->name);
+    string_freez(v->name);
     freez(v);
 }
 
diff --git a/libnetdata/eval/eval.h b/libnetdata/eval/eval.h
index 086d171aa..1633ec505 100644
--- a/libnetdata/eval/eval.h
+++ b/libnetdata/eval/eval.h
@@ -18,8 +18,7 @@ typedef enum rrdcalc_status {
 } RRDCALC_STATUS;
 
 typedef struct eval_variable {
-    char *name;
-    uint32_t hash;
+    STRING *name;
     struct eval_variable *next;
 } EVAL_VARIABLE;
 
@@ -70,19 +69,19 @@ typedef struct eval_expression {
 // parse the given string as an expression and return:
 //   a pointer to an expression if it parsed OK
 //   NULL in which case the pointer to error has the error code
-extern EVAL_EXPRESSION *expression_parse(const char *string, const char **failed_at, int *error);
+EVAL_EXPRESSION *expression_parse(const char *string, const char **failed_at, int *error);
 
 // free all resources allocated for an expression
-extern void expression_free(EVAL_EXPRESSION *expression);
+void expression_free(EVAL_EXPRESSION *expression);
 
 // convert an error code to a message
-extern const char *expression_strerror(int error);
+const char *expression_strerror(int error);
 
 // evaluate an expression and return
 // 1 = OK, the result is in: expression->result
 // 2 = FAILED, the error message is in: buffer_tostring(expression->error_msg)
-extern int expression_evaluate(EVAL_EXPRESSION *expression);
+int expression_evaluate(EVAL_EXPRESSION *expression);
 
-extern int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, NETDATA_DOUBLE *result);
+int health_variable_lookup(STRING *variable, struct rrdcalc *rc, NETDATA_DOUBLE *result);
 
 #endif //NETDATA_EVAL_H
diff --git a/libnetdata/health/health.h b/libnetdata/health/health.h
index f7580edab..6b8f9b384 100644
--- a/libnetdata/health/health.h
+++ b/libnetdata/health/health.h
@@ -46,10 +46,10 @@ typedef struct silencers {
 
 extern SILENCERS *silencers;
 
-extern SILENCER *create_silencer(void);
-extern int health_silencers_json_read_callback(JSON_ENTRY *e);
-extern void health_silencers_add(SILENCER *silencer);
-extern SILENCER * health_silencers_addparam(SILENCER *silencer, char *key, char *value);
-extern int health_initialize_global_silencers();
+SILENCER *create_silencer(void);
+int health_silencers_json_read_callback(JSON_ENTRY *e);
+void health_silencers_add(SILENCER *silencer);
+SILENCER * health_silencers_addparam(SILENCER *silencer, char *key, char *value);
+int health_initialize_global_silencers();
 
 #endif
diff --git a/libnetdata/inlined.h b/libnetdata/inlined.h
index 5c265fc01..aa7f3c213 100644
--- a/libnetdata/inlined.h
+++ b/libnetdata/inlined.h
@@ -42,24 +42,12 @@ static inline uint32_t simple_uhash(const char *name) {
     return hval;
 }
 
-static inline int simple_hash_strcmp(const char *name, const char *b, uint32_t *hash) {
-    unsigned char *s = (unsigned char *) name;
-    uint32_t hval = 0x811c9dc5;
-    int ret = 0;
-    while (*s) {
-        if(!ret) ret = *s - *b++;
-        hval *= 16777619;
-        hval ^= (uint32_t) *s++;
-    }
-    *hash = hval;
-    return ret;
-}
-
 static inline int str2i(const char *s) {
     int n = 0;
-    char c, negative = (*s == '-');
+    char c, negative = (char)(*s == '-');
+    const char *e = s + 30; // max number of character to iterate
 
-    for(c = (negative)?*(++s):*s; c >= '0' && c <= '9' ; c = *(++s)) {
+    for(c = (char)((negative)?*(++s):*s); c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -73,8 +61,9 @@ static inline int str2i(const char *s) {
 static inline long str2l(const char *s) {
     long n = 0;
     char c, negative = (*s == '-');
+    const char *e = &s[30]; // max number of character to iterate
 
-    for(c = (negative)?*(++s):*s; c >= '0' && c <= '9' ; c = *(++s)) {
+    for(c = (negative)?*(++s):*s; c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -88,7 +77,9 @@ static inline long str2l(const char *s) {
 static inline uint32_t str2uint32_t(const char *s) {
     uint32_t n = 0;
     char c;
-    for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+    const char *e = &s[30]; // max number of character to iterate
+
+    for(c = *s; c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -98,7 +89,9 @@ static inline uint32_t str2uint32_t(const char *s) {
 static inline uint64_t str2uint64_t(const char *s) {
     uint64_t n = 0;
     char c;
-    for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+    const char *e = &s[30]; // max number of character to iterate
+
+    for(c = *s; c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -108,7 +101,9 @@ static inline uint64_t str2uint64_t(const char *s) {
 static inline unsigned long str2ul(const char *s) {
     unsigned long n = 0;
     char c;
-    for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+    const char *e = &s[30]; // max number of character to iterate
+
+    for(c = *s; c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -118,7 +113,9 @@ static inline unsigned long str2ul(const char *s) {
 static inline unsigned long long str2ull(const char *s) {
     unsigned long long n = 0;
     char c;
-    for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+    const char *e = &s[30]; // max number of character to iterate
+
+    for(c = *s; c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -137,7 +134,9 @@ static inline long long str2ll(const char *s, char **endptr) {
 
     long long n = 0;
     char c;
-    for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+    const char *e = &s[30]; // max number of character to iterate
+
+    for(c = *s; c >= '0' && c <= '9' && s < e ; c = *(++s)) {
         n *= 10;
         n += c - '0';
     }
@@ -182,6 +181,42 @@ static inline void sanitize_json_string(char *dst, const char *src, size_t dst_s
     *dst = '\0';
 }
 
+static inline bool sanitize_command_argument_string(char *dst, const char *src, size_t dst_size) {
+    // skip leading dashes
+    while (src[0] == '-')
+        src++;
+
+    // escape single quotes
+    while (src[0] != '\0') {
+        if (src[0] == '\'') {
+            if (dst_size < 4)
+                return false;
+
+            dst[0] = '\''; dst[1] = '\\'; dst[2] = '\''; dst[3] = '\'';
+
+            dst += 4;
+            dst_size -= 4;
+        } else {
+            if (dst_size < 1)
+                return false;
+
+            dst[0] = src[0];
+
+            dst += 1;
+            dst_size -= 1;
+        }
+
+        src++;
+    }
+
+    // make sure we have space to terminate the string
+    if (dst_size == 0)
+        return false;
+    *dst = '\0';
+
+    return true;
+}
+
 static inline int read_file(const char *filename, char *buffer, size_t size) {
     if(unlikely(!size)) return 3;
 
diff --git a/libnetdata/json/json.c b/libnetdata/json/json.c
index e03556b50..d5f62edaf 100644
--- a/libnetdata/json/json.c
+++ b/libnetdata/json/json.c
@@ -102,7 +102,7 @@ int json_callback_print(JSON_ENTRY *e)
 
         case JSON_ARRAY:
             e->callback_function = json_callback_print;
-            sprintf(txt,"ARRAY[%lu]", e->data.items);
+            sprintf(txt,"ARRAY[%lu]", (long unsigned int) e->data.items);
             buffer_strcat(wb, txt);
             break;
 
@@ -553,4 +553,5 @@ int json_test(char *str)
 {
     return json_parse(str, NULL, json_callback_print);
 }
- */
\ No newline at end of file
+ */
+
diff --git a/libnetdata/libnetdata.c b/libnetdata/libnetdata.c
index 5b6c541ed..cc04a97eb 100644
--- a/libnetdata/libnetdata.c
+++ b/libnetdata/libnetdata.c
@@ -30,128 +30,367 @@ const char *program_version = VERSION;
 // its lifetime), these can be used to override the default system allocation
 // routines.
 
-#ifdef NETDATA_LOG_ALLOCATIONS
-#warning NETDATA_LOG_ALLOCATIONS ENABLED - set log_thread_memory_allocations=1 on any thread to log all its allocations - or use log_allocations() to log them on demand
-
-static __thread struct memory_statistics {
-    volatile ssize_t malloc_calls_made;
-    volatile ssize_t calloc_calls_made;
-    volatile ssize_t realloc_calls_made;
-    volatile ssize_t strdup_calls_made;
-    volatile ssize_t free_calls_made;
-    volatile ssize_t memory_calls_made;
-    volatile ssize_t allocated_memory;
-    volatile ssize_t mmapped_memory;
-} memory_statistics = { 0, 0, 0, 0, 0, 0, 0, 0 };
-
-__thread size_t log_thread_memory_allocations = 0;
-
-inline void log_allocations_int(const char *file, const char *function, const unsigned long line) {
-    static __thread struct memory_statistics old = { 0, 0, 0, 0, 0, 0, 0, 0 };
-
-    fprintf(stderr, "%s MEMORY ALLOCATIONS: (%04lu@%s:%s): Allocated %zd KiB (%+zd B), mmapped %zd KiB (%+zd B): : malloc %zd (%+zd), calloc %zd (%+zd), realloc %zd (%+zd), strdup %zd (%+zd), free %zd (%+zd)\n",
-            netdata_thread_tag(),
-            line, file, function,
-            (memory_statistics.allocated_memory + 512) / 1024, memory_statistics.allocated_memory - old.allocated_memory,
-            (memory_statistics.mmapped_memory + 512) / 1024, memory_statistics.mmapped_memory - old.mmapped_memory,
-            memory_statistics.malloc_calls_made, memory_statistics.malloc_calls_made - old.malloc_calls_made,
-            memory_statistics.calloc_calls_made, memory_statistics.calloc_calls_made - old.calloc_calls_made,
-            memory_statistics.realloc_calls_made, memory_statistics.realloc_calls_made - old.realloc_calls_made,
-            memory_statistics.strdup_calls_made, memory_statistics.strdup_calls_made - old.strdup_calls_made,
-            memory_statistics.free_calls_made, memory_statistics.free_calls_made - old.free_calls_made
-    );
-
-    memcpy(&old, &memory_statistics, sizeof(struct memory_statistics));
-}
-
-static inline void mmap_accounting(size_t size) {
-    if(log_thread_memory_allocations) {
-        memory_statistics.memory_calls_made++;
-        memory_statistics.mmapped_memory += size;
+#ifdef NETDATA_TRACE_ALLOCATIONS
+#warning NETDATA_TRACE_ALLOCATIONS ENABLED
+#include "Judy.h"
+
+#if defined(HAVE_DLSYM) && defined(ENABLE_DLSYM)
+#include <dlfcn.h>
+
+typedef void (*libc_function_t)(void);
+
+static void *malloc_first_run(size_t size);
+static void *(*libc_malloc)(size_t) = malloc_first_run;
+
+static void *calloc_first_run(size_t n, size_t size);
+static void *(*libc_calloc)(size_t, size_t) = calloc_first_run;
+
+static void *realloc_first_run(void *ptr, size_t size);
+static void *(*libc_realloc)(void *, size_t) = realloc_first_run;
+
+static void free_first_run(void *ptr);
+static void (*libc_free)(void *) = free_first_run;
+
+static char *strdup_first_run(const char *s);
+static char *(*libc_strdup)(const char *) = strdup_first_run;
+
+static size_t malloc_usable_size_first_run(void *ptr);
+#ifdef HAVE_MALLOC_USABLE_SIZE
+static size_t (*libc_malloc_usable_size)(void *) = malloc_usable_size_first_run;
+#else
+static size_t (*libc_malloc_usable_size)(void *) = NULL;
+#endif
+
+static void link_system_library_function(libc_function_t *func_pptr, const char *name, bool required) {
+    *func_pptr = dlsym(RTLD_NEXT, name);
+    if(!*func_pptr && required) {
+        fprintf(stderr, "FATAL: Cannot find system's %s() function.\n", name);
+        abort();
     }
 }
 
-void *mallocz_int(const char *file, const char *function, const unsigned long line, size_t size) {
-    memory_statistics.memory_calls_made++;
-    memory_statistics.malloc_calls_made++;
-    memory_statistics.allocated_memory += size;
+static void *malloc_first_run(size_t size) {
+    link_system_library_function((libc_function_t *) &libc_malloc, "malloc", true);
+    return libc_malloc(size);
+}
 
-    if(log_thread_memory_allocations)
-        log_allocations_int(file, function, line);
+static void *calloc_first_run(size_t n, size_t size) {
+    link_system_library_function((libc_function_t *) &libc_calloc, "calloc", true);
+    return libc_calloc(n, size);
+}
 
-    size_t *n = (size_t *)malloc(sizeof(size_t) + size);
-    if (unlikely(!n)) fatal("mallocz() cannot allocate %zu bytes of memory.", size);
-    *n = size;
-    return (void *)&n[1];
+static void *realloc_first_run(void *ptr, size_t size) {
+    link_system_library_function((libc_function_t *) &libc_realloc, "realloc", true);
+    return libc_realloc(ptr, size);
 }
 
-void *callocz_int(const char *file, const char *function, const unsigned long line, size_t nmemb, size_t size) {
-    size = nmemb * size;
+static void free_first_run(void *ptr) {
+    link_system_library_function((libc_function_t *) &libc_free, "free", true);
+    libc_free(ptr);
+}
+
+static char *strdup_first_run(const char *s) {
+    link_system_library_function((libc_function_t *) &libc_strdup, "strdup", true);
+    return libc_strdup(s);
+}
+
+static size_t malloc_usable_size_first_run(void *ptr) {
+    link_system_library_function((libc_function_t *) &libc_malloc_usable_size, "malloc_usable_size", false);
+
+    if(libc_malloc_usable_size)
+        return libc_malloc_usable_size(ptr);
+    else
+        return 0;
+}
+
+void *malloc(size_t size) {
+    return mallocz(size);
+}
+
+void *calloc(size_t n, size_t size) {
+    return callocz(n, size);
+}
+
+void *realloc(void *ptr, size_t size) {
+    return reallocz(ptr, size);
+}
+
+void *reallocarray(void *ptr, size_t n, size_t size) {
+    return reallocz(ptr, n * size);
+}
+
+void free(void *ptr) {
+    freez(ptr);
+}
+
+char *strdup(const char *s) {
+    return strdupz(s);
+}
+
+size_t malloc_usable_size(void *ptr) {
+    return mallocz_usable_size(ptr);
+}
+#else // !HAVE_DLSYM
+
+static void *(*libc_malloc)(size_t) = malloc;
+static void *(*libc_calloc)(size_t, size_t) = calloc;
+static void *(*libc_realloc)(void *, size_t) = realloc;
+static void (*libc_free)(void *) = free;
+
+#ifdef HAVE_MALLOC_USABLE_SIZE
+static size_t (*libc_malloc_usable_size)(void *) = malloc_usable_size;
+#else
+static size_t (*libc_malloc_usable_size)(void *) = NULL;
+#endif
 
-    memory_statistics.memory_calls_made++;
-    memory_statistics.calloc_calls_made++;
-    memory_statistics.allocated_memory += size;
-    if(log_thread_memory_allocations)
-        log_allocations_int(file, function, line);
+#endif // HAVE_DLSYM
 
-    size_t *n = (size_t *)calloc(1, sizeof(size_t) + size);
-    if (unlikely(!n)) fatal("callocz() cannot allocate %zu bytes of memory.", size);
-    *n = size;
-    return (void *)&n[1];
+
+void posix_memfree(void *ptr) {
+    libc_free(ptr);
+}
+
+Word_t JudyMalloc(Word_t Words) {
+    Word_t Addr;
+
+    Addr = (Word_t) mallocz(Words * sizeof(Word_t));
+    return(Addr);
+}
+void JudyFree(void * PWord, Word_t Words) {
+    (void)Words;
+    freez(PWord);
+}
+Word_t JudyMallocVirtual(Word_t Words) {
+    Word_t Addr;
+
+    Addr = (Word_t) mallocz(Words * sizeof(Word_t));
+    return(Addr);
+}
+void JudyFreeVirtual(void * PWord, Word_t Words) {
+    (void)Words;
+    freez(PWord);
+}
+
+#define MALLOC_ALIGNMENT (sizeof(uintptr_t) * 2)
+#define size_t_atomic_count(op, var, size) __atomic_## op ##_fetch(&(var), size, __ATOMIC_RELAXED)
+#define size_t_atomic_bytes(op, var, size) __atomic_## op ##_fetch(&(var), ((size) % MALLOC_ALIGNMENT)?((size) + MALLOC_ALIGNMENT - ((size) % MALLOC_ALIGNMENT)):(size), __ATOMIC_RELAXED)
+
+struct malloc_header_signature {
+    uint32_t magic;
+    uint32_t size;
+    struct malloc_trace *trace;
+};
+
+struct malloc_header {
+    struct malloc_header_signature signature;
+    uint8_t padding[(sizeof(struct malloc_header_signature) % MALLOC_ALIGNMENT) ? MALLOC_ALIGNMENT - (sizeof(struct malloc_header_signature) % MALLOC_ALIGNMENT) : 0];
+    uint8_t data[];
+};
+
+static size_t malloc_header_size = sizeof(struct malloc_header);
+
+int malloc_trace_compare(void *A, void *B) {
+    struct malloc_trace *a = A;
+    struct malloc_trace *b = B;
+    return strcmp(a->function, b->function);
+}
+
+static avl_tree_lock malloc_trace_index = {
+    .avl_tree = {
+        .root = NULL,
+        .compar = malloc_trace_compare},
+    .rwlock = NETDATA_RWLOCK_INITIALIZER
+};
+
+int malloc_trace_walkthrough(int (*callback)(void *item, void *data), void *data) {
+    return avl_traverse_lock(&malloc_trace_index, callback, data);
 }
 
-void *reallocz_int(const char *file, const char *function, const unsigned long line, void *ptr, size_t size) {
-    if(!ptr) return mallocz_int(file, function, line, size);
+NEVERNULL WARNUNUSED
+static struct malloc_trace *malloc_trace_find_or_create(const char *file, const char *function, size_t line) {
+    struct malloc_trace tmp = {
+        .line = line,
+        .function = function,
+        .file = file,
+    };
+
+    struct malloc_trace *t = (struct malloc_trace *)avl_search_lock(&malloc_trace_index, (avl_t *)&tmp);
+    if(!t) {
+        t = libc_calloc(1, sizeof(struct malloc_trace));
+        if(!t) fatal("No memory");
+        t->line = line;
+        t->function = function;
+        t->file = file;
+
+        struct malloc_trace *t2 = (struct malloc_trace *)avl_insert_lock(&malloc_trace_index, (avl_t *)t);
+        if(t2 != t)
+            free(t);
+
+        t = t2;
+    }
+
+    if(!t)
+        fatal("Cannot insert to AVL");
+
+    return t;
+}
+
+void malloc_trace_mmap(size_t size) {
+    struct malloc_trace *p = malloc_trace_find_or_create("unknown", "netdata_mmap", 1);
+    size_t_atomic_count(add, p->mmap_calls, 1);
+    size_t_atomic_count(add, p->allocations, 1);
+    size_t_atomic_bytes(add, p->bytes, size);
+}
+
+void malloc_trace_munmap(size_t size) {
+    struct malloc_trace *p = malloc_trace_find_or_create("unknown", "netdata_mmap", 1);
+    size_t_atomic_count(add, p->munmap_calls, 1);
+    size_t_atomic_count(sub, p->allocations, 1);
+    size_t_atomic_bytes(sub, p->bytes, size);
+}
+
+void *mallocz_int(size_t size, const char *file, const char *function, size_t line) {
+    struct malloc_trace *p = malloc_trace_find_or_create(file, function, line);
 
-    size_t *n = (size_t *)ptr;
-    n--;
-    size_t old_size = *n;
+    size_t_atomic_count(add, p->malloc_calls, 1);
+    size_t_atomic_count(add, p->allocations, 1);
+    size_t_atomic_bytes(add, p->bytes, size);
 
-    n = realloc(n, sizeof(size_t) + size);
-    if (unlikely(!n)) fatal("reallocz() cannot allocate %zu bytes of memory (from %zu bytes).", size, old_size);
+    struct malloc_header *t = (struct malloc_header *)libc_malloc(malloc_header_size + size);
+    if (unlikely(!t)) fatal("mallocz() cannot allocate %zu bytes of memory (%zu with header).", size, malloc_header_size + size);
+    t->signature.magic = 0x0BADCAFE;
+    t->signature.trace = p;
+    t->signature.size = size;
 
-    memory_statistics.memory_calls_made++;
-    memory_statistics.realloc_calls_made++;
-    memory_statistics.allocated_memory += (size - old_size);
-    if(log_thread_memory_allocations)
-        log_allocations_int(file, function, line);
+#ifdef NETDATA_INTERNAL_CHECKS
+    for(ssize_t i = 0; i < (ssize_t)sizeof(t->padding) ;i++) // signed to avoid compiler warning when zero-padded
+        t->padding[i] = 0xFF;
+#endif
+
+    return (void *)&t->data;
+}
+
+void *callocz_int(size_t nmemb, size_t size, const char *file, const char *function, size_t line) {
+    struct malloc_trace *p = malloc_trace_find_or_create(file, function, line);
+    size = nmemb * size;
 
-    *n = size;
-    return (void *)&n[1];
+    size_t_atomic_count(add, p->calloc_calls, 1);
+    size_t_atomic_count(add, p->allocations, 1);
+    size_t_atomic_bytes(add, p->bytes, size);
+
+    struct malloc_header *t = (struct malloc_header *)libc_calloc(1, malloc_header_size + size);
+    if (unlikely(!t)) fatal("mallocz() cannot allocate %zu bytes of memory (%zu with header).", size, malloc_header_size + size);
+    t->signature.magic = 0x0BADCAFE;
+    t->signature.trace = p;
+    t->signature.size = size;
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    for(ssize_t i = 0; i < (ssize_t)sizeof(t->padding) ;i++) // signed to avoid compiler warning when zero-padded
+        t->padding[i] = 0xFF;
+#endif
+
+    return &t->data;
 }
 
-char *strdupz_int(const char *file, const char *function, const unsigned long line, const char *s) {
+char *strdupz_int(const char *s, const char *file, const char *function, size_t line) {
+    struct malloc_trace *p = malloc_trace_find_or_create(file, function, line);
     size_t size = strlen(s) + 1;
 
-    memory_statistics.memory_calls_made++;
-    memory_statistics.strdup_calls_made++;
-    memory_statistics.allocated_memory += size;
-    if(log_thread_memory_allocations)
-        log_allocations_int(file, function, line);
+    size_t_atomic_count(add, p->strdup_calls, 1);
+    size_t_atomic_count(add, p->allocations, 1);
+    size_t_atomic_bytes(add, p->bytes, size);
 
-    size_t *n = (size_t *)malloc(sizeof(size_t) + size);
-    if (unlikely(!n)) fatal("strdupz() cannot allocate %zu bytes of memory.", size);
+    struct malloc_header *t = (struct malloc_header *)libc_malloc(malloc_header_size + size);
+    if (unlikely(!t)) fatal("strdupz() cannot allocate %zu bytes of memory (%zu with header).", size, malloc_header_size + size);
+    t->signature.magic = 0x0BADCAFE;
+    t->signature.trace = p;
+    t->signature.size = size;
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    for(ssize_t i = 0; i < (ssize_t)sizeof(t->padding) ;i++) // signed to avoid compiler warning when zero-padded
+        t->padding[i] = 0xFF;
+#endif
+
+    memcpy(&t->data, s, size);
+    return (char *)&t->data;
+}
+
+static struct malloc_header *malloc_get_header(void *ptr, const char *caller, const char *file, const char *function, size_t line) {
+    uint8_t *ret = (uint8_t *)ptr - malloc_header_size;
+    struct malloc_header *t = (struct malloc_header *)ret;
+
+    if(t->signature.magic != 0x0BADCAFE) {
+        error("pointer %p is not our pointer (called %s() from %zu@%s, %s()).", ptr, caller, line, file, function);
+        return NULL;
+    }
 
-    *n = size;
-    char *t = (char *)&n[1];
-    strcpy(t, s);
     return t;
 }
 
-void freez_int(const char *file, const char *function, const unsigned long line, void *ptr) {
+void *reallocz_int(void *ptr, size_t size, const char *file, const char *function, size_t line) {
+    if(!ptr) return mallocz_int(size, file, function, line);
+
+    struct malloc_header *t = malloc_get_header(ptr, __FUNCTION__, file, function, line);
+    if(!t)
+        return libc_realloc(ptr, size);
+
+    if(t->signature.size == size) return ptr;
+    size_t_atomic_count(add, t->signature.trace->free_calls, 1);
+    size_t_atomic_count(sub, t->signature.trace->allocations, 1);
+    size_t_atomic_bytes(sub, t->signature.trace->bytes, t->signature.size);
+
+    struct malloc_trace *p = malloc_trace_find_or_create(file, function, line);
+    size_t_atomic_count(add, p->realloc_calls, 1);
+    size_t_atomic_count(add, p->allocations, 1);
+    size_t_atomic_bytes(add, p->bytes, size);
+
+    t = (struct malloc_header *)libc_realloc(t, malloc_header_size + size);
+    if (unlikely(!t)) fatal("reallocz() cannot allocate %zu bytes of memory (%zu with header).", size, malloc_header_size + size);
+    t->signature.magic = 0x0BADCAFE;
+    t->signature.trace = p;
+    t->signature.size = size;
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    for(ssize_t i = 0; i < (ssize_t)sizeof(t->padding) ;i++) // signed to avoid compiler warning when zero-padded
+        t->padding[i] = 0xFF;
+#endif
+
+    return (void *)&t->data;
+}
+
+size_t mallocz_usable_size_int(void *ptr, const char *file, const char *function, size_t line) {
+    if(unlikely(!ptr)) return 0;
+
+    struct malloc_header *t = malloc_get_header(ptr, __FUNCTION__, file, function, line);
+    if(!t) {
+        if(libc_malloc_usable_size)
+            return libc_malloc_usable_size(ptr);
+        else
+            return 0;
+    }
+
+    return t->signature.size;
+}
+
+void freez_int(void *ptr, const char *file, const char *function, size_t line) {
     if(unlikely(!ptr)) return;
 
-    size_t *n = (size_t *)ptr;
-    n--;
-    size_t size = *n;
+    struct malloc_header *t = malloc_get_header(ptr, __FUNCTION__, file, function, line);
+    if(!t) {
+        libc_free(ptr);
+        return;
+    }
+
+    size_t_atomic_count(add, t->signature.trace->free_calls, 1);
+    size_t_atomic_count(sub, t->signature.trace->allocations, 1);
+    size_t_atomic_bytes(sub, t->signature.trace->bytes, t->signature.size);
 
-    memory_statistics.memory_calls_made++;
-    memory_statistics.free_calls_made++;
-    memory_statistics.allocated_memory -= size;
-    if(log_thread_memory_allocations)
-        log_allocations_int(file, function, line);
+#ifdef NETDATA_INTERNAL_CHECKS
+    // it should crash if it is used after freeing it
+    memset(t, 0, malloc_header_size + t->signature.size);
+#endif
 
-    free(n);
+    libc_free(t);
 }
 #else
 
@@ -184,6 +423,10 @@ void *reallocz(void *ptr, size_t size) {
     return p;
 }
 
+void posix_memfree(void *ptr) {
+    free(ptr);
+}
+
 #endif
 
 // --------------------------------------------------------------------------------------------------------------------
@@ -1031,8 +1274,8 @@ void *netdata_mmap(const char *filename, size_t size, int flags, int ksm) {
     mem = mmap(NULL, size, PROT_READ | PROT_WRITE, flags, fd_for_mmap, 0);
     if (mem != MAP_FAILED) {
 
-#ifdef NETDATA_LOG_ALLOCATIONS
-        mmap_accounting(size);
+#ifdef NETDATA_TRACE_ALLOCATIONS
+        malloc_trace_mmap(size);
 #endif
 
         // if we have a file open, but we didn't give it to mmap(),
@@ -1059,6 +1302,13 @@ cleanup:
     return mem;
 }
 
+int netdata_munmap(void *ptr, size_t size) {
+#ifdef NETDATA_TRACE_ALLOCATIONS
+    malloc_trace_munmap(size);
+#endif
+    return munmap(ptr, size);
+}
+
 int memory_file_save(const char *filename, void *mem, size_t size) {
     char tmpfilename[FILENAME_MAX + 1];
 
@@ -1535,6 +1785,122 @@ char *find_and_replace(const char *src, const char *find, const char *replace, c
     return value;
 }
 
+inline int pluginsd_space(char c) {
+    switch(c) {
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+        case '=':
+            return 1;
+
+        default:
+            return 0;
+    }
+}
+
+inline int config_isspace(char c)
+{
+    switch (c) {
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+        case ',':
+            return 1;
+
+        default:
+            return 0;
+    }
+}
+
+// split a text into words, respecting quotes
+inline size_t quoted_strings_splitter(char *str, char **words, size_t max_words, int (*custom_isspace)(char), char *recover_input, char **recover_location, int max_recover)
+{
+    char *s = str, quote = 0;
+    size_t i = 0;
+    int rec = 0;
+    char *recover = recover_input;
+
+    // skip all white space
+    while (unlikely(custom_isspace(*s)))
+        s++;
+
+    // check for quote
+    if (unlikely(*s == '\'' || *s == '"')) {
+        quote = *s; // remember the quote
+        s++;        // skip the quote
+    }
+
+    // store the first word
+    words[i++] = s;
+
+    // while we have something
+    while (likely(*s)) {
+        // if it is escape
+        if (unlikely(*s == '\\' && s[1])) {
+            s += 2;
+            continue;
+        }
+
+        // if it is quote
+        else if (unlikely(*s == quote)) {
+            quote = 0;
+            if (recover && rec < max_recover) {
+                recover_location[rec++] = s;
+                *recover++ = *s;
+            }
+            *s = ' ';
+            continue;
+        }
+
+        // if it is a space
+        else if (unlikely(quote == 0 && custom_isspace(*s))) {
+            // terminate the word
+            if (recover && rec < max_recover) {
+                if (!rec || recover_location[rec-1] != s) {
+                    recover_location[rec++] = s;
+                    *recover++ = *s;
+                }
+            }
+            *s++ = '\0';
+
+            // skip all white space
+            while (likely(custom_isspace(*s)))
+                s++;
+
+            // check for quote
+            if (unlikely(*s == '\'' || *s == '"')) {
+                quote = *s; // remember the quote
+                s++;        // skip the quote
+            }
+
+            // if we reached the end, stop
+            if (unlikely(!*s))
+                break;
+
+            // store the next word
+            if (likely(i < max_words))
+                words[i++] = s;
+            else
+                break;
+        }
+
+        // anything else
+        else
+            s++;
+    }
+
+    if (i < max_words)
+        words[i] = NULL;
+
+    return i;
+}
+
+inline size_t pluginsd_split_words(char *str, char **words, size_t max_words, char *recover_input, char **recover_location, int max_recover)
+{
+    return quoted_strings_splitter(str, words, max_words, pluginsd_space, recover_input, recover_location, max_recover);
+}
 
 bool bitmap256_get_bit(BITMAP256 *ptr, uint8_t idx) {
     if (unlikely(!ptr))
@@ -1550,3 +1916,21 @@ void bitmap256_set_bit(BITMAP256 *ptr, uint8_t idx, bool value) {
     else
         ptr->data[idx / 64] &= ~(1ULL << (idx % 64));
 }
+
+bool run_command_and_copy_output_to_stdout(const char *command, int max_line_length) {
+    pid_t pid;
+    FILE *fp = netdata_popen(command, &pid, NULL);
+
+    if(fp) {
+        char buffer[max_line_length + 1];
+        while (fgets(buffer, max_line_length, fp))
+            fprintf(stdout, "%s", buffer);
+    }
+    else {
+        error("Failed to execute command '%s'.", command);
+        return false;
+    }
+
+    netdata_pclose(NULL, fp, pid);
+    return true;
+}
diff --git a/libnetdata/libnetdata.h b/libnetdata/libnetdata.h
index 8cc6cce9f..58eaa9ded 100644
--- a/libnetdata/libnetdata.h
+++ b/libnetdata/libnetdata.h
@@ -11,6 +11,15 @@ extern "C" {
 #include <config.h>
 #endif
 
+#if defined(NETDATA_DEV_MODE) && !defined(NETDATA_INTERNAL_CHECKS)
+#define NETDATA_INTERNAL_CHECKS 1
+#endif
+
+// NETDATA_TRACE_ALLOCATIONS does not work under musl libc, so don't enable it
+//#if defined(NETDATA_INTERNAL_CHECKS) && !defined(NETDATA_TRACE_ALLOCATIONS)
+//#define NETDATA_TRACE_ALLOCATIONS 1
+//#endif
+
 #define OS_LINUX   1
 #define OS_FREEBSD 2
 #define OS_MACOS   3
@@ -214,68 +223,142 @@ extern "C" {
 
 #define GUID_LEN 36
 
-extern void netdata_fix_chart_id(char *s);
-extern void netdata_fix_chart_name(char *s);
-
-extern void strreverse(char* begin, char* end);
-extern char *mystrsep(char **ptr, char *s);
-extern char *trim(char *s); // remove leading and trailing spaces; may return NULL
-extern char *trim_all(char *buffer); // like trim(), but also remove duplicate spaces inside the string; may return NULL
-
-extern int  vsnprintfz(char *dst, size_t n, const char *fmt, va_list args);
-extern int  snprintfz(char *dst, size_t n, const char *fmt, ...) PRINTFLIKE(3, 4);
+// ---------------------------------------------------------------------------------------------
+// double linked list management
+
+#define DOUBLE_LINKED_LIST_PREPEND_UNSAFE(head, item, prev, next)                              \
+    do {                                                                                       \
+        (item)->next = (head);                                                                 \
+                                                                                               \
+        if(likely(head)) {                                                                     \
+            (item)->prev = (head)->prev;                                                       \
+            (head)->prev = (item);                                                             \
+        }                                                                                      \
+        else                                                                                   \
+            (item)->prev = (item);                                                             \
+                                                                                               \
+        (head) = (item);                                                                       \
+    } while (0)
+
+#define DOUBLE_LINKED_LIST_APPEND_UNSAFE(head, item, prev, next)                               \
+    do {                                                                                       \
+        if(likely(head)) {                                                                     \
+            (item)->prev = (head)->prev;                                                       \
+            (head)->prev->next = (item);                                                       \
+            (head)->prev = (item);                                                             \
+            (item)->next = NULL;                                                               \
+        }                                                                                      \
+        else {                                                                                 \
+            (head) = (item);                                                                   \
+            (head)->prev = (head);                                                             \
+            (head)->next = NULL;                                                               \
+        }                                                                                      \
+                                                                                               \
+    } while (0)
+
+#define DOUBLE_LINKED_LIST_REMOVE_UNSAFE(head, item, prev, next)                               \
+    do {                                                                                       \
+        fatal_assert((head) != NULL);                                                          \
+        fatal_assert((item)->prev != NULL);                                                    \
+                                                                                               \
+        if((item)->prev == (item)) {                                                           \
+            /* it is the only item in the list */                                              \
+            (head) = NULL;                                                                     \
+        }                                                                                      \
+        else if((item) == (head)) {                                                            \
+            /* it is the first item */                                                         \
+            (item)->next->prev = (item)->prev;                                                 \
+            (head) = (item)->next;                                                             \
+        }                                                                                      \
+        else {                                                                                 \
+            (item)->prev->next = (item)->next;                                                 \
+            if ((item)->next) {                                                                \
+                (item)->next->prev = (item)->prev;                                             \
+            }                                                                                  \
+            else {                                                                             \
+                (head)->prev = (item)->prev;                                                   \
+            }                                                                                  \
+        }                                                                                      \
+                                                                                               \
+        (item)->next = NULL;                                                                   \
+        (item)->prev = NULL;                                                                   \
+    } while (0)
+
+#define DOUBLE_LINKED_LIST_FOREACH_FORWARD(head, var, prev, next)                              \
+    for ((var) = (head); (var) ; (var) = (var)->next)
+
+#define DOUBLE_LINKED_LIST_FOREACH_BACKWARD(head, var, prev, next)                             \
+    for ((var) = (head)?(head)->prev:NULL; (var) && (var) != (head)->prev ; (var) = (var)->prev)
+
+// ---------------------------------------------------------------------------------------------
+
+
+void netdata_fix_chart_id(char *s);
+void netdata_fix_chart_name(char *s);
+
+void strreverse(char* begin, char* end);
+char *mystrsep(char **ptr, char *s);
+char *trim(char *s); // remove leading and trailing spaces; may return NULL
+char *trim_all(char *buffer); // like trim(), but also remove duplicate spaces inside the string; may return NULL
+
+int  vsnprintfz(char *dst, size_t n, const char *fmt, va_list args);
+int  snprintfz(char *dst, size_t n, const char *fmt, ...) PRINTFLIKE(3, 4);
 
 // memory allocation functions that handle failures
-#ifdef NETDATA_LOG_ALLOCATIONS
-extern __thread size_t log_thread_memory_allocations;
-#define strdupz(s) strdupz_int(__FILE__, __FUNCTION__, __LINE__, s)
-#define callocz(nmemb, size) callocz_int(__FILE__, __FUNCTION__, __LINE__, nmemb, size)
-#define mallocz(size) mallocz_int(__FILE__, __FUNCTION__, __LINE__, size)
-#define reallocz(ptr, size) reallocz_int(__FILE__, __FUNCTION__, __LINE__, ptr, size)
-#define freez(ptr) freez_int(__FILE__, __FUNCTION__, __LINE__, ptr)
-#define log_allocations() log_allocations_int(__FILE__, __FUNCTION__, __LINE__)
-
-extern char *strdupz_int(const char *file, const char *function, const unsigned long line, const char *s);
-extern void *callocz_int(const char *file, const char *function, const unsigned long line, size_t nmemb, size_t size);
-extern void *mallocz_int(const char *file, const char *function, const unsigned long line, size_t size);
-extern void *reallocz_int(const char *file, const char *function, const unsigned long line, void *ptr, size_t size);
-extern void freez_int(const char *file, const char *function, const unsigned long line, void *ptr);
-extern void log_allocations_int(const char *file, const char *function, const unsigned long line);
-
-#else // NETDATA_LOG_ALLOCATIONS
-extern char *strdupz(const char *s) MALLOCLIKE NEVERNULL;
-extern void *callocz(size_t nmemb, size_t size) MALLOCLIKE NEVERNULL;
-extern void *mallocz(size_t size) MALLOCLIKE NEVERNULL;
-extern void *reallocz(void *ptr, size_t size) MALLOCLIKE NEVERNULL;
-extern void freez(void *ptr);
-#endif // NETDATA_LOG_ALLOCATIONS
-
-extern void json_escape_string(char *dst, const char *src, size_t size);
-extern void json_fix_string(char *s);
-
-extern void *netdata_mmap(const char *filename, size_t size, int flags, int ksm);
-extern int memory_file_save(const char *filename, void *mem, size_t size);
-
-extern int fd_is_valid(int fd);
+#ifdef NETDATA_TRACE_ALLOCATIONS
+int malloc_trace_walkthrough(int (*callback)(void *item, void *data), void *data);
+
+#define strdupz(s) strdupz_int(s, __FILE__, __FUNCTION__, __LINE__)
+#define callocz(nmemb, size) callocz_int(nmemb, size, __FILE__, __FUNCTION__, __LINE__)
+#define mallocz(size) mallocz_int(size, __FILE__, __FUNCTION__, __LINE__)
+#define reallocz(ptr, size) reallocz_int(ptr, size, __FILE__, __FUNCTION__, __LINE__)
+#define freez(ptr) freez_int(ptr, __FILE__, __FUNCTION__, __LINE__)
+#define mallocz_usable_size(ptr) mallocz_usable_size_int(ptr, __FILE__, __FUNCTION__, __LINE__)
+
+char *strdupz_int(const char *s, const char *file, const char *function, size_t line);
+void *callocz_int(size_t nmemb, size_t size, const char *file, const char *function, size_t line);
+void *mallocz_int(size_t size, const char *file, const char *function, size_t line);
+void *reallocz_int(void *ptr, size_t size, const char *file, const char *function, size_t line);
+void freez_int(void *ptr, const char *file, const char *function, size_t line);
+size_t mallocz_usable_size_int(void *ptr, const char *file, const char *function, size_t line);
+
+#else // NETDATA_TRACE_ALLOCATIONS
+char *strdupz(const char *s) MALLOCLIKE NEVERNULL;
+void *callocz(size_t nmemb, size_t size) MALLOCLIKE NEVERNULL;
+void *mallocz(size_t size) MALLOCLIKE NEVERNULL;
+void *reallocz(void *ptr, size_t size) MALLOCLIKE NEVERNULL;
+void freez(void *ptr);
+#endif // NETDATA_TRACE_ALLOCATIONS
+
+void posix_memfree(void *ptr);
+
+void json_escape_string(char *dst, const char *src, size_t size);
+void json_fix_string(char *s);
+
+void *netdata_mmap(const char *filename, size_t size, int flags, int ksm);
+int netdata_munmap(void *ptr, size_t size);
+int memory_file_save(const char *filename, void *mem, size_t size);
+
+int fd_is_valid(int fd);
 
 extern struct rlimit rlimit_nofile;
 
 extern int enable_ksm;
 
-extern char *fgets_trim_len(char *buf, size_t buf_size, FILE *fp, size_t *len);
+char *fgets_trim_len(char *buf, size_t buf_size, FILE *fp, size_t *len);
 
-extern int verify_netdata_host_prefix();
+int verify_netdata_host_prefix();
 
-extern int recursively_delete_dir(const char *path, const char *reason);
+int recursively_delete_dir(const char *path, const char *reason);
 
 extern volatile sig_atomic_t netdata_exit;
 
 extern const char *program_version;
 
-extern char *strdupz_path_subpath(const char *path, const char *subpath);
-extern int path_is_dir(const char *path, const char *subpath);
-extern int path_is_file(const char *path, const char *subpath);
-extern void recursive_config_double_dir_load(
+char *strdupz_path_subpath(const char *path, const char *subpath);
+int path_is_dir(const char *path, const char *subpath);
+int path_is_file(const char *path, const char *subpath);
+void recursive_config_double_dir_load(
         const char *user_path
         , const char *stock_path
         , const char *subpath
@@ -283,8 +366,8 @@ extern void recursive_config_double_dir_load(
         , void *data
         , size_t depth
 );
-extern char *read_by_filename(char *filename, long *file_size);
-extern char *find_and_replace(const char *src, const char *find, const char *replace, const char *where);
+char *read_by_filename(char *filename, long *file_size);
+char *find_and_replace(const char *src, const char *find, const char *replace, const char *where);
 
 /* fix for alpine linux */
 #ifndef RUSAGE_THREAD
@@ -315,12 +398,30 @@ typedef struct bitmap256 {
     uint64_t data[4];
 } BITMAP256;
 
-extern bool bitmap256_get_bit(BITMAP256 *ptr, uint8_t idx);
-extern void bitmap256_set_bit(BITMAP256 *ptr, uint8_t idx, bool value);
+bool bitmap256_get_bit(BITMAP256 *ptr, uint8_t idx);
+void bitmap256_set_bit(BITMAP256 *ptr, uint8_t idx, bool value);
 
-extern void netdata_cleanup_and_exit(int ret) NORETURN;
-extern void send_statistics(const char *action, const char *action_result, const char *action_data);
+#define COMPRESSION_MAX_MSG_SIZE 0x4000
+#define PLUGINSD_LINE_MAX (COMPRESSION_MAX_MSG_SIZE - 1024)
+int config_isspace(char c);
+int pluginsd_space(char c);
+
+size_t quoted_strings_splitter(char *str, char **words, size_t max_words, int (*custom_isspace)(char), char *recover_input, char **recover_location, int max_recover);
+size_t pluginsd_split_words(char *str, char **words, size_t max_words, char *recover_string, char **recover_location, int max_recover);
+
+static inline char *get_word(char **words, size_t num_words, size_t index) {
+    if (index >= num_words)
+        return NULL;
+
+    return words[index];
+}
+
+bool run_command_and_copy_output_to_stdout(const char *command, int max_line_length);
+
+void netdata_cleanup_and_exit(int ret) NORETURN;
+void send_statistics(const char *action, const char *action_result, const char *action_data);
 extern char *netdata_configured_host_prefix;
+#include "libjudy/src/Judy.h"
 #include "os.h"
 #include "storage_number/storage_number.h"
 #include "threads/threads.h"
@@ -340,6 +441,7 @@ extern char *netdata_configured_host_prefix;
 #include "config/appconfig.h"
 #include "log/log.h"
 #include "procfile/procfile.h"
+#include "string/string.h"
 #include "dictionary/dictionary.h"
 #if defined(HAVE_LIBBPF) && !defined(__cplusplus)
 #include "ebpf/ebpf.h"
@@ -356,7 +458,8 @@ extern char *netdata_configured_host_prefix;
 #include "worker_utilization/worker_utilization.h"
 
 // BEWARE: Outside of the C code this also exists in alarm-notify.sh
-#define DEFAULT_CLOUD_BASE_URL "https://app.netdata.cloud"
+#define DEFAULT_CLOUD_BASE_URL "https://api.netdata.cloud"
+#define DEFAULT_CLOUD_UI_URL "https://app.netdata.cloud"
 
 #define RRD_STORAGE_TIERS 5
 
@@ -370,6 +473,33 @@ static inline size_t struct_natural_alignment(size_t size) {
     return size;
 }
 
+#ifdef NETDATA_TRACE_ALLOCATIONS
+struct malloc_trace {
+    avl_t avl;
+
+    const char *function;
+    const char *file;
+    size_t line;
+
+    size_t malloc_calls;
+    size_t calloc_calls;
+    size_t realloc_calls;
+    size_t strdup_calls;
+    size_t free_calls;
+
+    size_t mmap_calls;
+    size_t munmap_calls;
+
+    size_t allocations;
+    size_t bytes;
+
+    struct rrddim *rd_bytes;
+    struct rrddim *rd_allocations;
+    struct rrddim *rd_avg_alloc;
+    struct rrddim *rd_ops;
+};
+#endif // NETDATA_TRACE_ALLOCATIONS
+
 # ifdef __cplusplus
 }
 # endif
diff --git a/libnetdata/locks/README.md b/libnetdata/locks/README.md
index 9ac96a8f6..9132edc43 100644
--- a/libnetdata/locks/README.md
+++ b/libnetdata/locks/README.md
@@ -49,7 +49,7 @@ The library maintains a linked-list of all the lock holders (one entry per threa
 If any call is expected to pause the caller (ie the caller is attempting a read lock while there is a write lock in place and vice versa), the library will log something like this:
 
 ```
-RW_LOCK ON LOCK 0x0x5651c9fcce20: 4190039 'HEALTH' (function init_pending_foreach_alarms() 661@health/health.c) WANTS a 'W' lock (while holding 1 rwlocks and 1 mutexes).
+RW_LOCK ON LOCK 0x0x5651c9fcce20: 4190039 'HEALTH' (function health_execute_pending_updates() 661@health/health.c) WANTS a 'W' lock (while holding 1 rwlocks and 1 mutexes).
 There are 7 readers and 0 writers are holding the lock:
      => 1: RW_LOCK: process 4190091 'WEB_SERVER[static14]' (function web_client_api_request_v1_data() 526@web/api/web_api_v1.c) is having 1 'R' lock for 709847 usec.
      => 2: RW_LOCK: process 4190079 'WEB_SERVER[static6]' (function web_client_api_request_v1_data() 526@web/api/web_api_v1.c) is having 1 'R' lock for 709869 usec.
@@ -63,9 +63,9 @@ There are 7 readers and 0 writers are holding the lock:
 And each of the above is paired with a `GOT` log, like this:
 
 ```
-RW_LOCK ON LOCK 0x0x5651c9fcce20: 4190039 'HEALTH' (function init_pending_foreach_alarms() 661@health/health.c) GOT a 'W' lock (while holding 2 rwlocks and 1 mutexes).
+RW_LOCK ON LOCK 0x0x5651c9fcce20: 4190039 'HEALTH' (function health_execute_pending_updates() 661@health/health.c) GOT a 'W' lock (while holding 2 rwlocks and 1 mutexes).
 There are 0 readers and 1 writers are holding the lock:
-     => 1: RW_LOCK: process 4190039 'HEALTH' (function init_pending_foreach_alarms() 661@health/health.c) is having 1 'W' lock for 36 usec.
+     => 1: RW_LOCK: process 4190039 'HEALTH' (function health_execute_pending_updates() 661@health/health.c) is having 1 'W' lock for 36 usec.
 ```
 
 Keep in mind that the lock and log are not atomic. The list of callers is indicative (and sometimes just empty because the original holders of the lock, unlocked it until we had the chance to print their names).
diff --git a/libnetdata/locks/locks.c b/libnetdata/locks/locks.c
index 8b5348678..f7191be52 100644
--- a/libnetdata/locks/locks.c
+++ b/libnetdata/locks/locks.c
@@ -278,6 +278,37 @@ int __netdata_rwlock_trywrlock(netdata_rwlock_t *rwlock) {
     return ret;
 }
 
+// ----------------------------------------------------------------------------
+// spinlock implementation
+// https://www.youtube.com/watch?v=rmGJc9PXpuE&t=41s
+
+void netdata_spinlock_init(SPINLOCK *spinlock) {
+    *spinlock = NETDATA_SPINLOCK_INITIALIZER;
+}
+
+void netdata_spinlock_lock(SPINLOCK *spinlock) {
+    static const struct timespec ns = { .tv_sec = 0, .tv_nsec = 1 };
+
+    netdata_thread_disable_cancelability();
+
+    for(int i = 1;
+        __atomic_load_n(&spinlock->locked, __ATOMIC_RELAXED) ||
+        __atomic_test_and_set(&spinlock->locked, __ATOMIC_ACQUIRE)
+        ; i++
+        ) {
+        if(unlikely(i == 8)) {
+            i = 0;
+            nanosleep(&ns, NULL);
+        }
+    }
+    // we have the lock
+}
+
+void netdata_spinlock_unlock(SPINLOCK *spinlock) {
+    __atomic_clear(&spinlock->locked, __ATOMIC_RELEASE);
+    netdata_thread_enable_cancelability();
+}
+
 #ifdef NETDATA_TRACE_RWLOCKS
 
 // ----------------------------------------------------------------------------
diff --git a/libnetdata/locks/locks.h b/libnetdata/locks/locks.h
index 796b53c6d..4d2d1655c 100644
--- a/libnetdata/locks/locks.h
+++ b/libnetdata/locks/locks.h
@@ -9,6 +9,14 @@
 typedef pthread_mutex_t netdata_mutex_t;
 #define NETDATA_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 
+typedef struct netdata_spinlock {
+    bool locked;
+} SPINLOCK;
+#define NETDATA_SPINLOCK_INITIALIZER (SPINLOCK){ .locked = false }
+void netdata_spinlock_init(SPINLOCK *spinlock);
+void netdata_spinlock_lock(SPINLOCK *spinlock);
+void netdata_spinlock_unlock(SPINLOCK *spinlock);
+
 #ifdef NETDATA_TRACE_RWLOCKS
 typedef struct netdata_rwlock_locker {
     pid_t pid;
@@ -51,38 +59,38 @@ typedef struct netdata_rwlock_t {
 
 #endif // NETDATA_TRACE_RWLOCKS
 
-extern int __netdata_mutex_init(netdata_mutex_t *mutex);
-extern int __netdata_mutex_destroy(netdata_mutex_t *mutex);
-extern int __netdata_mutex_lock(netdata_mutex_t *mutex);
-extern int __netdata_mutex_trylock(netdata_mutex_t *mutex);
-extern int __netdata_mutex_unlock(netdata_mutex_t *mutex);
+int __netdata_mutex_init(netdata_mutex_t *mutex);
+int __netdata_mutex_destroy(netdata_mutex_t *mutex);
+int __netdata_mutex_lock(netdata_mutex_t *mutex);
+int __netdata_mutex_trylock(netdata_mutex_t *mutex);
+int __netdata_mutex_unlock(netdata_mutex_t *mutex);
 
-extern int __netdata_rwlock_destroy(netdata_rwlock_t *rwlock);
-extern int __netdata_rwlock_init(netdata_rwlock_t *rwlock);
-extern int __netdata_rwlock_rdlock(netdata_rwlock_t *rwlock);
-extern int __netdata_rwlock_wrlock(netdata_rwlock_t *rwlock);
-extern int __netdata_rwlock_unlock(netdata_rwlock_t *rwlock);
-extern int __netdata_rwlock_tryrdlock(netdata_rwlock_t *rwlock);
-extern int __netdata_rwlock_trywrlock(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_destroy(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_init(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_rdlock(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_wrlock(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_unlock(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_tryrdlock(netdata_rwlock_t *rwlock);
+int __netdata_rwlock_trywrlock(netdata_rwlock_t *rwlock);
 
-extern void netdata_thread_disable_cancelability(void);
-extern void netdata_thread_enable_cancelability(void);
+void netdata_thread_disable_cancelability(void);
+void netdata_thread_enable_cancelability(void);
 
 #ifdef NETDATA_TRACE_RWLOCKS
 
-extern int netdata_mutex_init_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
-extern int netdata_mutex_destroy_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
-extern int netdata_mutex_lock_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
-extern int netdata_mutex_trylock_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
-extern int netdata_mutex_unlock_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
-
-extern int netdata_rwlock_destroy_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
-extern int netdata_rwlock_init_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
-extern int netdata_rwlock_rdlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
-extern int netdata_rwlock_wrlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
-extern int netdata_rwlock_unlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
-extern int netdata_rwlock_tryrdlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
-extern int netdata_rwlock_trywrlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_mutex_init_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
+int netdata_mutex_destroy_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
+int netdata_mutex_lock_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
+int netdata_mutex_trylock_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
+int netdata_mutex_unlock_debug( const char *file, const char *function, const unsigned long line, netdata_mutex_t *mutex);
+
+int netdata_rwlock_destroy_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_rwlock_init_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_rwlock_rdlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_rwlock_wrlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_rwlock_unlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_rwlock_tryrdlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
+int netdata_rwlock_trywrlock_debug( const char *file, const char *function, const unsigned long line, netdata_rwlock_t *rwlock);
 
 #define netdata_mutex_init(mutex)    netdata_mutex_init_debug(__FILE__, __FUNCTION__, __LINE__, mutex)
 #define netdata_mutex_destroy(mutex) netdata_mutex_init_debug(__FILE__, __FUNCTION__, __LINE__, mutex)
diff --git a/libnetdata/log/log.c b/libnetdata/log/log.c
index d6793b69b..fb3b2d034 100644
--- a/libnetdata/log/log.c
+++ b/libnetdata/log/log.c
@@ -3,6 +3,10 @@
 #include <daemon/main.h>
 #include "../libnetdata.h"
 
+#ifdef HAVE_BACKTRACE
+#include <execinfo.h>
+#endif
+
 int web_server_is_multithreaded = 1;
 
 const char *program_name = "";
@@ -11,14 +15,19 @@ uint64_t debug_flags = 0;
 int access_log_syslog = 1;
 int error_log_syslog = 1;
 int output_log_syslog = 1;  // debug log
+int health_log_syslog = 1;
 
 int stdaccess_fd = -1;
 FILE *stdaccess = NULL;
 
+int stdhealth_fd = -1;
+FILE *stdhealth = NULL;
+
 const char *stdaccess_filename = NULL;
 const char *stderr_filename = NULL;
 const char *stdout_filename = NULL;
 const char *facility_log = NULL;
+const char *stdhealth_filename = NULL;
 
 #ifdef ENABLE_ACLK
 const char *aclklog_filename = NULL;
@@ -451,16 +460,13 @@ void syslog_init() {
     }
 }
 
-#define LOG_DATE_LENGTH 26
-
-static inline void log_date(char *buffer, size_t len) {
+void log_date(char *buffer, size_t len, time_t now) {
     if(unlikely(!buffer || !len))
         return;
 
-    time_t t;
+    time_t t = now;
     struct tm *tmp, tmbuf;
 
-    t = now_realtime_sec();
     tmp = localtime_r(&t, &tmbuf);
 
     if (tmp == NULL) {
@@ -576,7 +582,10 @@ void reopen_all_log_files() {
 #endif
 
     if(stdaccess_filename)
-         stdaccess = open_log_file(stdaccess_fd, stdaccess, stdaccess_filename, &access_log_syslog, 1, &stdaccess_fd);
+        stdaccess = open_log_file(stdaccess_fd, stdaccess, stdaccess_filename, &access_log_syslog, 1, &stdaccess_fd);
+
+    if(stdhealth_filename)
+        stdhealth = open_log_file(stdhealth_fd, stdhealth, stdhealth_filename, &health_log_syslog, 1, &stdhealth_fd);
 }
 
 void open_all_log_files() {
@@ -592,6 +601,8 @@ void open_all_log_files() {
 #endif
 
     stdaccess = open_log_file(stdaccess_fd, stdaccess, stdaccess_filename, &access_log_syslog, 1, &stdaccess_fd);
+
+    stdhealth = open_log_file(stdhealth_fd, stdhealth, stdhealth_filename, &health_log_syslog, 1, &stdhealth_fd);
 }
 
 // ----------------------------------------------------------------------------
@@ -625,7 +636,7 @@ int error_log_limit(int reset) {
     if(reset) {
         if(prevented) {
             char date[LOG_DATE_LENGTH];
-            log_date(date, LOG_DATE_LENGTH);
+            log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
             fprintf(
                 stderr,
                 "%s: %s LOG FLOOD PROTECTION reset for process '%s' "
@@ -648,7 +659,7 @@ int error_log_limit(int reset) {
     if(now - start > error_log_throttle_period) {
         if(prevented) {
             char date[LOG_DATE_LENGTH];
-            log_date(date, LOG_DATE_LENGTH);
+            log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
             fprintf(
                 stderr,
                 "%s: %s LOG FLOOD PROTECTION resuming logging from process '%s' "
@@ -672,7 +683,7 @@ int error_log_limit(int reset) {
     if(counter > error_log_errors_per_period) {
         if(!prevented) {
             char date[LOG_DATE_LENGTH];
-            log_date(date, LOG_DATE_LENGTH);
+            log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
             fprintf(
                 stderr,
                 "%s: %s LOG FLOOD PROTECTION too many logs (%lu logs in %"PRId64" seconds, threshold is set to %lu logs "
@@ -727,7 +738,7 @@ void debug_int( const char *file, const char *function, const unsigned long line
     va_list args;
 
     char date[LOG_DATE_LENGTH];
-    log_date(date, LOG_DATE_LENGTH);
+    log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
 
     va_start( args, fmt );
     printf("%s: %s DEBUG : %s : (%04lu@%-20.20s:%-15.15s): ", date, program_name, netdata_thread_tag(), line, file, function);
@@ -747,7 +758,7 @@ void debug_int( const char *file, const char *function, const unsigned long line
 // ----------------------------------------------------------------------------
 // info log
 
-void info_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... )
+void info_int( const char *file __maybe_unused, const char *function __maybe_unused, const unsigned long line __maybe_unused, const char *fmt, ... )
 {
     va_list args;
 
@@ -766,7 +777,7 @@ void info_int( const char *file, const char *function, const unsigned long line,
     }
 
     char date[LOG_DATE_LENGTH];
-    log_date(date, LOG_DATE_LENGTH);
+    log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
 
     va_start( args, fmt );
 #ifdef NETDATA_INTERNAL_CHECKS
@@ -807,7 +818,10 @@ static const char *strerror_result_string(const char *a, const char *b) { (void)
 #error "cannot detect the format of function strerror_r()"
 #endif
 
-void error_int( const char *prefix, const char *file, const char *function, const unsigned long line, const char *fmt, ... ) {
+void error_limit_int(ERROR_LIMIT *erl, const char *prefix, const char *file __maybe_unused, const char *function __maybe_unused, const unsigned long line __maybe_unused, const char *fmt, ... ) {
+    if(erl->sleep_ut)
+        sleep_usec(erl->sleep_ut);
+
     // save a copy of errno - just in case this function generates a new error
     int __errno = errno;
 
@@ -815,6 +829,13 @@ void error_int( const char *prefix, const char *file, const char *function, cons
 
     log_lock();
 
+    erl->count++;
+    time_t now = now_boottime_sec();
+    if(now - erl->last_logged < erl->log_every) {
+        log_unlock();
+        return;
+    }
+
     // prevent logging too much
     if (error_log_limit(0)) {
         log_unlock();
@@ -828,7 +849,7 @@ void error_int( const char *prefix, const char *file, const char *function, cons
     }
 
     char date[LOG_DATE_LENGTH];
-    log_date(date, LOG_DATE_LENGTH);
+    log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
 
     va_start( args, fmt );
 #ifdef NETDATA_INTERNAL_CHECKS
@@ -839,6 +860,12 @@ void error_int( const char *prefix, const char *file, const char *function, cons
     vfprintf( stderr, fmt, args );
     va_end( args );
 
+    if(erl->count > 1)
+        fprintf(stderr, " (similar messages repeated %zu times in the last %llu secs)", erl->count, (unsigned long long)(erl->last_logged ? now - erl->last_logged : 0));
+
+    if(erl->sleep_ut)
+        fprintf(stderr, " (sleeping for %llu microseconds every time this happens)", erl->sleep_ut);
+
     if(__errno) {
         char buf[1024];
         fprintf(stderr, " (errno %d, %s)\n", __errno, strerror_result(strerror_r(__errno, buf, 1023), buf));
@@ -847,9 +874,74 @@ void error_int( const char *prefix, const char *file, const char *function, cons
     else
         fputc('\n', stderr);
 
+    erl->last_logged = now;
+    erl->count = 0;
+
     log_unlock();
 }
 
+void error_int(const char *prefix, const char *file __maybe_unused, const char *function __maybe_unused, const unsigned long line __maybe_unused, const char *fmt, ... ) {
+    // save a copy of errno - just in case this function generates a new error
+    int __errno = errno;
+
+    va_list args;
+
+    log_lock();
+
+    // prevent logging too much
+    if (error_log_limit(0)) {
+        log_unlock();
+        return;
+    }
+
+    if(error_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_ERR,  fmt, args );
+        va_end( args );
+    }
+
+    char date[LOG_DATE_LENGTH];
+    log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
+
+    va_start( args, fmt );
+#ifdef NETDATA_INTERNAL_CHECKS
+    fprintf(stderr, "%s: %s %-5.5s : %s : (%04lu@%-20.20s:%-15.15s): ", date, program_name, prefix, netdata_thread_tag(), line, file, function);
+#else
+    fprintf(stderr, "%s: %s %-5.5s : %s : ", date, program_name, prefix, netdata_thread_tag());
+#endif
+    vfprintf( stderr, fmt, args );
+    va_end( args );
+
+    if(__errno) {
+        char buf[1024];
+        fprintf(stderr, " (errno %d, %s)\n", __errno, strerror_result(strerror_r(__errno, buf, 1023), buf));
+        errno = 0;
+    }
+    else
+        fputc('\n', stderr);
+
+    log_unlock();
+}
+
+#ifdef NETDATA_INTERNAL_CHECKS
+static void crash_netdata(void) {
+    // make Netdata core dump
+    abort();
+}
+#endif
+
+#ifdef HAVE_BACKTRACE
+#define BT_BUF_SIZE 100
+static void print_call_stack(void) {
+    int nptrs;
+    void *buffer[BT_BUF_SIZE];
+
+    nptrs = backtrace(buffer, BT_BUF_SIZE);
+    if(nptrs)
+        backtrace_symbols_fd(buffer, nptrs, fileno(stderr));
+}
+#endif
+
 void fatal_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) {
     // save a copy of errno - just in case this function generates a new error
     int __errno = errno;
@@ -872,7 +964,7 @@ void fatal_int( const char *file, const char *function, const unsigned long line
     }
 
     char date[LOG_DATE_LENGTH];
-    log_date(date, LOG_DATE_LENGTH);
+    log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
 
     log_lock();
 
@@ -897,6 +989,14 @@ void fatal_int( const char *file, const char *function, const unsigned long line
     snprintfz(action_result, 60, "%s:%s", program_name, strncmp(thread_tag, "STREAM_RECEIVER", strlen("STREAM_RECEIVER")) ? thread_tag : "[x]");
     send_statistics("FATAL", action_result, action_data);
 
+#ifdef HAVE_BACKTRACE
+    print_call_stack();
+#endif
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    crash_netdata();
+#endif
+
     netdata_cleanup_and_exit(1);
 }
 
@@ -919,7 +1019,7 @@ void log_access( const char *fmt, ... ) {
             netdata_mutex_lock(&access_mutex);
 
         char date[LOG_DATE_LENGTH];
-        log_date(date, LOG_DATE_LENGTH);
+        log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
         fprintf(stdaccess, "%s: ", date);
 
         va_start( args, fmt );
@@ -932,6 +1032,38 @@ void log_access( const char *fmt, ... ) {
     }
 }
 
+// ----------------------------------------------------------------------------
+// health log
+
+void log_health( const char *fmt, ... ) {
+    va_list args;
+
+    if(health_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_INFO,  fmt, args );
+        va_end( args );
+    }
+
+    if(stdhealth) {
+        static netdata_mutex_t health_mutex = NETDATA_MUTEX_INITIALIZER;
+
+        if(web_server_is_multithreaded)
+            netdata_mutex_lock(&health_mutex);
+
+        char date[LOG_DATE_LENGTH];
+        log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
+        fprintf(stdhealth, "%s: ", date);
+
+        va_start( args, fmt );
+        vfprintf( stdhealth, fmt, args );
+        va_end( args );
+        fputc('\n', stdhealth);
+
+        if(web_server_is_multithreaded)
+            netdata_mutex_unlock(&health_mutex);
+    }
+}
+
 #ifdef ENABLE_ACLK
 void log_aclk_message_bin( const char *data, const size_t data_len, int tx, const char *mqtt_topic, const char *message_name) {
     if (aclklog) {
@@ -939,7 +1071,7 @@ void log_aclk_message_bin( const char *data, const size_t data_len, int tx, cons
         netdata_mutex_lock(&aclklog_mutex);
 
         char date[LOG_DATE_LENGTH];
-        log_date(date, LOG_DATE_LENGTH);
+        log_date(date, LOG_DATE_LENGTH, now_realtime_sec());
         fprintf(aclklog, "%s: %s Msg:\"%s\", MQTT-topic:\"%s\": ", date, tx ? "OUTGOING" : "INCOMING", message_name, mqtt_topic);
 
         fwrite(data, data_len, 1, aclklog);
diff --git a/libnetdata/log/log.h b/libnetdata/log/log.h
index ae86720cb..11dab4c1d 100644
--- a/libnetdata/log/log.h
+++ b/libnetdata/log/log.h
@@ -45,6 +45,8 @@ extern "C" {
 #define D_ACLK              0x0000000200000000
 #define D_METADATALOG       0x0000000400000000
 #define D_ACLK_SYNC         0x0000000800000000
+#define D_META_SYNC         0x0000001000000000
+#define D_REPLICATION       0x0000002000000000
 #define D_SYSTEM            0x8000000000000000
 
 extern int web_server_is_multithreaded;
@@ -56,9 +58,13 @@ extern const char *program_name;
 extern int stdaccess_fd;
 extern FILE *stdaccess;
 
+extern int stdhealth_fd;
+extern FILE *stdhealth;
+
 extern const char *stdaccess_filename;
 extern const char *stderr_filename;
 extern const char *stdout_filename;
+extern const char *stdhealth_filename;
 extern const char *facility_log;
 
 #ifdef ENABLE_ACLK
@@ -71,42 +77,61 @@ extern int aclklog_enabled;
 extern int access_log_syslog;
 extern int error_log_syslog;
 extern int output_log_syslog;
+extern int health_log_syslog;
 
 extern time_t error_log_throttle_period;
 extern unsigned long error_log_errors_per_period, error_log_errors_per_period_backup;
-extern int error_log_limit(int reset);
+int error_log_limit(int reset);
+
+void open_all_log_files();
+void reopen_all_log_files();
 
-extern void open_all_log_files();
-extern void reopen_all_log_files();
+#define LOG_DATE_LENGTH 26
+void log_date(char *buffer, size_t len, time_t now);
 
 static inline void debug_dummy(void) {}
 
 void error_log_limit_reset(void);
 void error_log_limit_unlimited(void);
 
+typedef struct error_with_limit {
+    time_t log_every;
+    size_t count;
+    time_t last_logged;
+    usec_t sleep_ut;
+} ERROR_LIMIT;
+
+#define error_limit_static_global_var(var, log_every_secs, sleep_usecs) static ERROR_LIMIT var = { .last_logged = 0, .count = 0, .log_every = (log_every_secs), .sleep_ut = (sleep_usecs) }
+#define error_limit_static_thread_var(var, log_every_secs, sleep_usecs) static __thread ERROR_LIMIT var = { .last_logged = 0, .count = 0, .log_every = (log_every_secs), .sleep_ut = (sleep_usecs) }
+
 #ifdef NETDATA_INTERNAL_CHECKS
 #define debug(type, args...) do { if(unlikely(debug_flags & type)) debug_int(__FILE__, __FUNCTION__, __LINE__, ##args); } while(0)
 #define internal_error(condition, args...) do { if(unlikely(condition)) error_int("IERR", __FILE__, __FUNCTION__, __LINE__, ##args); } while(0)
+#define internal_fatal(condition, args...) do { if(unlikely(condition)) fatal_int(__FILE__, __FUNCTION__, __LINE__, ##args); } while(0)
 #else
 #define debug(type, args...) debug_dummy()
 #define internal_error(args...) debug_dummy()
+#define internal_fatal(args...) debug_dummy()
 #endif
 
 #define info(args...)    info_int(__FILE__, __FUNCTION__, __LINE__, ##args)
 #define infoerr(args...) error_int("INFO", __FILE__, __FUNCTION__, __LINE__, ##args)
 #define error(args...)   error_int("ERROR", __FILE__, __FUNCTION__, __LINE__, ##args)
+#define error_limit(erl, args...)   error_limit_int(erl, "ERROR", __FILE__, __FUNCTION__, __LINE__, ##args)
 #define fatal(args...)   fatal_int(__FILE__, __FUNCTION__, __LINE__, ##args)
 #define fatal_assert(expr) ((expr) ? (void)(0) : fatal_int(__FILE__, __FUNCTION__, __LINE__, "Assertion `%s' failed", #expr))
 
-extern void send_statistics(const char *action, const char *action_result, const char *action_data);
-extern void debug_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(4, 5);
-extern void info_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(4, 5);
-extern void error_int( const char *prefix, const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(5, 6);
-extern void fatal_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) NORETURN PRINTFLIKE(4, 5);
-extern void log_access( const char *fmt, ... ) PRINTFLIKE(1, 2);
+void send_statistics(const char *action, const char *action_result, const char *action_data);
+void debug_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(4, 5);
+void info_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(4, 5);
+void error_int( const char *prefix, const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(5, 6);
+void error_limit_int(ERROR_LIMIT *erl, const char *prefix, const char *file __maybe_unused, const char *function __maybe_unused, unsigned long line __maybe_unused, const char *fmt, ... ) PRINTFLIKE(6, 7);;
+void fatal_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) NORETURN PRINTFLIKE(4, 5);
+void log_access( const char *fmt, ... ) PRINTFLIKE(1, 2);
+void log_health( const char *fmt, ... ) PRINTFLIKE(1, 2);
 
 #ifdef ENABLE_ACLK
-extern void log_aclk_message_bin( const char *data, const size_t data_len, int tx, const char *mqtt_topic, const char *message_name);
+void log_aclk_message_bin( const char *data, const size_t data_len, int tx, const char *mqtt_topic, const char *message_name);
 #endif
 
 # ifdef __cplusplus
diff --git a/libnetdata/onewayalloc/onewayalloc.h b/libnetdata/onewayalloc/onewayalloc.h
index 9eb908bfb..e536e0542 100644
--- a/libnetdata/onewayalloc/onewayalloc.h
+++ b/libnetdata/onewayalloc/onewayalloc.h
@@ -5,15 +5,15 @@
 
 typedef void ONEWAYALLOC;
 
-extern ONEWAYALLOC *onewayalloc_create(size_t size_hint);
-extern void onewayalloc_destroy(ONEWAYALLOC *owa);
+ONEWAYALLOC *onewayalloc_create(size_t size_hint);
+void onewayalloc_destroy(ONEWAYALLOC *owa);
 
-extern void *onewayalloc_mallocz(ONEWAYALLOC *owa, size_t size);
-extern void *onewayalloc_callocz(ONEWAYALLOC *owa, size_t nmemb, size_t size);
-extern char *onewayalloc_strdupz(ONEWAYALLOC *owa, const char *s);
-extern void *onewayalloc_memdupz(ONEWAYALLOC *owa, const void *src, size_t size);
-extern void onewayalloc_freez(ONEWAYALLOC *owa, const void *ptr);
+void *onewayalloc_mallocz(ONEWAYALLOC *owa, size_t size);
+void *onewayalloc_callocz(ONEWAYALLOC *owa, size_t nmemb, size_t size);
+char *onewayalloc_strdupz(ONEWAYALLOC *owa, const char *s);
+void *onewayalloc_memdupz(ONEWAYALLOC *owa, const void *src, size_t size);
+void onewayalloc_freez(ONEWAYALLOC *owa, const void *ptr);
 
-extern void *onewayalloc_doublesize(ONEWAYALLOC *owa, const void *src, size_t oldsize);
+void *onewayalloc_doublesize(ONEWAYALLOC *owa, const void *src, size_t oldsize);
 
 #endif // ONEWAYALLOC_H
diff --git a/libnetdata/os.h b/libnetdata/os.h
index 5e7746df8..67abf0be4 100644
--- a/libnetdata/os.h
+++ b/libnetdata/os.h
@@ -13,21 +13,21 @@
 #include <sys/sysctl.h>
 
 #define GETSYSCTL_BY_NAME(name, var) getsysctl_by_name(name, &(var), sizeof(var))
-extern int getsysctl_by_name(const char *name, void *ptr, size_t len);
+int getsysctl_by_name(const char *name, void *ptr, size_t len);
 
 #define GETSYSCTL_MIB(name, mib) getsysctl_mib(name, mib, sizeof(mib)/sizeof(int))
 
-extern int getsysctl_mib(const char *name, int *mib, size_t len);
+int getsysctl_mib(const char *name, int *mib, size_t len);
 
 #define GETSYSCTL_SIMPLE(name, mib, var) getsysctl_simple(name, mib, sizeof(mib)/sizeof(int), &(var), sizeof(var))
 #define GETSYSCTL_WSIZE(name, mib, var, size) getsysctl_simple(name, mib, sizeof(mib)/sizeof(int), var, size)
 
-extern int getsysctl_simple(const char *name, int *mib, size_t miblen, void *ptr, size_t len);
+int getsysctl_simple(const char *name, int *mib, size_t miblen, void *ptr, size_t len);
 
 #define GETSYSCTL_SIZE(name, mib, size) getsysctl(name, mib, sizeof(mib)/sizeof(int), NULL, &(size))
 #define GETSYSCTL(name, mib, var, size) getsysctl(name, mib, sizeof(mib)/sizeof(int), &(var), &(size))
 
-extern int getsysctl(const char *name, int *mib, size_t miblen, void *ptr, size_t *len);
+int getsysctl(const char *name, int *mib, size_t miblen, void *ptr, size_t *len);
 
 #endif
 
@@ -39,7 +39,7 @@ extern int getsysctl(const char *name, int *mib, size_t miblen, void *ptr, size_
 #include <sys/sysctl.h>
 
 #define GETSYSCTL_BY_NAME(name, var) getsysctl_by_name(name, &(var), sizeof(var))
-extern int getsysctl_by_name(const char *name, void *ptr, size_t len);
+int getsysctl_by_name(const char *name, void *ptr, size_t len);
 
 #endif
 
@@ -49,13 +49,13 @@ extern int getsysctl_by_name(const char *name, void *ptr, size_t len);
 extern const char *os_type;
 
 extern int processors;
-extern long get_system_cpus(void);
+long get_system_cpus(void);
 
 extern pid_t pid_max;
-extern pid_t get_system_pid_max(void);
+pid_t get_system_pid_max(void);
 
 extern unsigned int system_hz;
-extern void get_system_HZ(void);
+void get_system_HZ(void);
 
 #include <sys/timex.h>
 #if defined(__FreeBSD__) || defined(__APPLE__)
diff --git a/libnetdata/popen/popen.c b/libnetdata/popen/popen.c
index eaeffd32d..57f957f63 100644
--- a/libnetdata/popen/popen.c
+++ b/libnetdata/popen/popen.c
@@ -2,81 +2,129 @@
 
 #include "../libnetdata.h"
 
-static pthread_mutex_t myp_lock;
-static int myp_tracking = 0;
+// ----------------------------------------------------------------------------
+// popen with tracking
 
-struct mypopen {
+static pthread_mutex_t netdata_popen_tracking_mutex;
+static bool netdata_popen_tracking_enabled = false;
+
+struct netdata_popen {
     pid_t pid;
-    struct mypopen *next;
-    struct mypopen *prev;
+    struct netdata_popen *next;
+    struct netdata_popen *prev;
 };
 
-static struct mypopen *mypopen_root = NULL;
+static struct netdata_popen *netdata_popen_root = NULL;
 
 // myp_add_lock takes the lock if we're tracking.
-static void myp_add_lock(void) {
-    if (myp_tracking == 0)
+static void netdata_popen_tracking_lock(void) {
+    if(!netdata_popen_tracking_enabled)
         return;
 
-    netdata_mutex_lock(&myp_lock);
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
 }
 
 // myp_add_unlock release the lock if we're tracking.
-static void myp_add_unlock(void) {
-    if (myp_tracking == 0)
+static void netdata_popen_tracking_unlock(void) {
+    if(!netdata_popen_tracking_enabled)
         return;
 
-    netdata_mutex_unlock(&myp_lock);
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
 }
 
 // myp_add_locked adds pid if we're tracking.
 // myp_add_lock must have been called previously.
-static void myp_add_locked(pid_t pid) {
-    struct mypopen *mp;
-
-    if (myp_tracking == 0)
+static void netdata_popen_tracking_add_pid_unsafe(pid_t pid) {
+    if(!netdata_popen_tracking_enabled)
         return;
 
-    mp = mallocz(sizeof(struct mypopen));
+    struct netdata_popen *mp;
+
+    mp = mallocz(sizeof(struct netdata_popen));
     mp->pid = pid;
 
-    mp->next = mypopen_root;
-    mp->prev = NULL;
-    if (mypopen_root != NULL)
-        mypopen_root->prev = mp;
-    mypopen_root = mp;
-    netdata_mutex_unlock(&myp_lock);
+    DOUBLE_LINKED_LIST_PREPEND_UNSAFE(netdata_popen_root, mp, prev, next);
 }
 
 // myp_del deletes pid if we're tracking.
-static void myp_del(pid_t pid) {
-    struct mypopen *mp;
-
-    if (myp_tracking == 0)
+static void netdata_popen_tracking_del_pid(pid_t pid) {
+    if(!netdata_popen_tracking_enabled)
         return;
 
-    netdata_mutex_lock(&myp_lock);
-    for (mp = mypopen_root; mp != NULL; mp = mp->next) {
-        if (mp->pid == pid) {
-            if (mp->next != NULL)
-                mp->next->prev = mp->prev;
-            if (mp->prev != NULL)
-                mp->prev->next = mp->next;
-            if (mypopen_root == mp)
-                mypopen_root = mp->next;
-            freez(mp);
+    struct netdata_popen *mp;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+
+    DOUBLE_LINKED_LIST_FOREACH_FORWARD(netdata_popen_root, mp, prev, next) {
+        if(unlikely(mp->pid == pid))
             break;
-        }
     }
 
-    if (mp == NULL)
+    if(mp) {
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(netdata_popen_root, mp, prev, next);
+        freez(mp);
+    }
+    else
         error("Cannot find pid %d.", pid);
 
-    netdata_mutex_unlock(&myp_lock);
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
 }
 
-#define PIPE_READ 0
-#define PIPE_WRITE 1
+// netdata_popen_tracking_init() should be called by apps which act as init
+// (pid 1) so that processes created by mypopen and mypopene
+// are tracked. This enables the reaper to ignore processes
+// which will be handled internally, by calling myp_reap, to
+// avoid issues with already reaped processes during wait calls.
+//
+// Callers should call myp_free() to clean up resources.
+void netdata_popen_tracking_init(void) {
+    info("process tracking enabled.");
+    netdata_popen_tracking_enabled = true;
+
+    if (netdata_mutex_init(&netdata_popen_tracking_mutex) != 0)
+        fatal("netdata_popen_tracking_init() mutex init failed.");
+}
+
+// myp_free cleans up any resources allocated for process
+// tracking.
+void netdata_popen_tracking_cleanup(void) {
+    if(!netdata_popen_tracking_enabled)
+        return;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+    netdata_popen_tracking_enabled = false;
+
+    while(netdata_popen_root) {
+        struct netdata_popen *mp = netdata_popen_root;
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(netdata_popen_root, mp, prev, next);
+        freez(mp);
+    }
+
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
+}
+
+// myp_reap returns 1 if pid should be reaped, 0 otherwise.
+int netdata_popen_tracking_pid_shoud_be_reaped(pid_t pid) {
+    if(!netdata_popen_tracking_enabled)
+        return 0;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+
+    int ret = 1;
+    struct netdata_popen *mp;
+    DOUBLE_LINKED_LIST_FOREACH_FORWARD(netdata_popen_root, mp, prev, next) {
+        if(unlikely(mp->pid == pid)) {
+            ret = 0;
+            break;
+        }
+    }
+
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
+    return ret;
+}
+
+// ----------------------------------------------------------------------------
+// helpers
 
 static inline void convert_argv_to_string(char *dst, size_t size, const char *spawn_argv[]) {
     int i;
@@ -89,118 +137,191 @@ static inline void convert_argv_to_string(char *dst, size_t size, const char *sp
     }
 }
 
+// ----------------------------------------------------------------------------
+// the core of netdata popen
+
 /*
  * Returns -1 on failure, 0 on success. When POPEN_FLAG_CREATE_PIPE is set, on success set the FILE *fp pointer.
  */
-static int custom_popene(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp, const char *command, const char *spawn_argv[]) {
+#define PIPE_READ 0
+#define PIPE_WRITE 1
+
+static int popene_internal(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp_child_stdin, FILE **fpp_child_stdout, const char *command, const char *spawn_argv[]) {
     // create a string to be logged about the command we are running
     char command_to_be_logged[2048];
     convert_argv_to_string(command_to_be_logged, sizeof(command_to_be_logged), spawn_argv);
     // info("custom_popene() running command: %s", command_to_be_logged);
 
-    FILE *fp = NULL;
-    int ret = 0; // success by default
-    int pipefd[2], error;
+    int ret = 0;     // success by default
+    int attr_rc = 1; // failure by default
+
+    FILE *fp_child_stdin = NULL, *fp_child_stdout = NULL;
+    int pipefd_stdin[2] = { -1, -1 };
+    int pipefd_stdout[2] = { -1, -1 };
+
     pid_t pid;
     posix_spawnattr_t attr;
     posix_spawn_file_actions_t fa;
 
-    if (flags & POPEN_FLAG_CREATE_PIPE) {
-        if (pipe(pipefd) == -1)
-            return -1;
-        if ((fp = fdopen(pipefd[PIPE_READ], "r")) == NULL) {
-            goto error_after_pipe;
+    int stdin_fd_to_exclude_from_closing = -1;
+    int stdout_fd_to_exclude_from_closing = -1;
+
+    if(posix_spawn_file_actions_init(&fa)) {
+        error("POPEN: posix_spawn_file_actions_init() failed.");
+        ret = -1;
+        goto set_return_values_and_return;
+    }
+
+    if(fpp_child_stdin) {
+        if (pipe(pipefd_stdin) == -1) {
+            error("POPEN: stdin pipe() failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if ((fp_child_stdin = fdopen(pipefd_stdin[PIPE_WRITE], "w")) == NULL) {
+            error("POPEN: fdopen() stdin failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if(posix_spawn_file_actions_adddup2(&fa, pipefd_stdin[PIPE_READ], STDIN_FILENO)) {
+            error("POPEN: posix_spawn_file_actions_adddup2() on stdin failed.");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+    }
+    else {
+        if (posix_spawn_file_actions_addopen(&fa, STDIN_FILENO, "/dev/null", O_RDONLY, 0)) {
+            error("POPEN: posix_spawn_file_actions_addopen() on stdin to /dev/null failed.");
+            // this is not a fatal error
+            stdin_fd_to_exclude_from_closing = STDIN_FILENO;
         }
     }
 
-    if (flags & POPEN_FLAG_CLOSE_FD) {
-        // Mark all files to be closed by the exec() stage of posix_spawn()
-        int i;
-        for (i = (int) (sysconf(_SC_OPEN_MAX) - 1); i >= 0; i--) {
-            if (i != STDIN_FILENO && i != STDERR_FILENO)
-                (void) fcntl(i, F_SETFD, FD_CLOEXEC);
+    if (fpp_child_stdout) {
+        if (pipe(pipefd_stdout) == -1) {
+            error("POPEN: stdout pipe() failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if ((fp_child_stdout = fdopen(pipefd_stdout[PIPE_READ], "r")) == NULL) {
+            error("POPEN: fdopen() stdout failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if(posix_spawn_file_actions_adddup2(&fa, pipefd_stdout[PIPE_WRITE], STDOUT_FILENO)) {
+            error("POPEN: posix_spawn_file_actions_adddup2() on stdout failed.");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+    }
+    else {
+        if (posix_spawn_file_actions_addopen(&fa, STDOUT_FILENO, "/dev/null", O_WRONLY, 0)) {
+            error("POPEN: posix_spawn_file_actions_addopen() on stdout to /dev/null failed.");
+            // this is not a fatal error
+            stdout_fd_to_exclude_from_closing = STDOUT_FILENO;
         }
     }
 
-    if (!posix_spawn_file_actions_init(&fa)) {
-        if (flags & POPEN_FLAG_CREATE_PIPE) {
-            // move the pipe to stdout in the child
-            if (posix_spawn_file_actions_adddup2(&fa, pipefd[PIPE_WRITE], STDOUT_FILENO)) {
-                error("posix_spawn_file_actions_adddup2() failed");
-                goto error_after_posix_spawn_file_actions_init;
-            }
-        } else {
-            // set stdout to /dev/null
-            if (posix_spawn_file_actions_addopen(&fa, STDOUT_FILENO, "/dev/null", O_WRONLY, 0)) {
-                error("posix_spawn_file_actions_addopen() failed");
-                // this is not a fatal error
-            }
+    if(flags & POPEN_FLAG_CLOSE_FD) {
+        // Mark all files to be closed by the exec() stage of posix_spawn()
+        for(int i = (int)(sysconf(_SC_OPEN_MAX) - 1); i >= 0; i--) {
+            if(likely(i != STDERR_FILENO && i != stdin_fd_to_exclude_from_closing && i != stdout_fd_to_exclude_from_closing))
+                (void)fcntl(i, F_SETFD, FD_CLOEXEC);
         }
-    } else {
-        error("posix_spawn_file_actions_init() failed.");
-        goto error_after_pipe;
     }
-    if (!(error = posix_spawnattr_init(&attr))) {
+
+    attr_rc = posix_spawnattr_init(&attr);
+    if(attr_rc) {
+        // failed
+        error("POPEN: posix_spawnattr_init() failed.");
+    }
+    else {
+        // success
         // reset all signals in the child
-        sigset_t mask;
 
         if (posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF))
-            error("posix_spawnattr_setflags() failed.");
+            error("POPEN: posix_spawnattr_setflags() failed.");
+
+        sigset_t mask;
         sigemptyset(&mask);
+
         if (posix_spawnattr_setsigmask(&attr, &mask))
-            error("posix_spawnattr_setsigmask() failed.");
-    } else {
-        error("posix_spawnattr_init() failed.");
+            error("POPEN: posix_spawnattr_setsigmask() failed.");
     }
 
     // Take the lock while we fork to ensure we don't race with SIGCHLD
     // delivery on a process which exits quickly.
-    myp_add_lock();
+    netdata_popen_tracking_lock();
     if (!posix_spawn(&pid, command, &fa, &attr, (char * const*)spawn_argv, env)) {
+        // success
         *pidptr = pid;
-        myp_add_locked(pid);
-        debug(D_CHILDS, "Spawned command: \"%s\" on pid %d from parent pid %d.", command_to_be_logged, pid, getpid());
-    } else {
-        myp_add_unlock();
-        error("Failed to spawn command: \"%s\" from parent pid %d.", command_to_be_logged, getpid());
-        if (flags & POPEN_FLAG_CREATE_PIPE) {
-            fclose(fp);
-        }
-        ret = -1;
+        netdata_popen_tracking_add_pid_unsafe(pid);
+        netdata_popen_tracking_unlock();
     }
-    if (flags & POPEN_FLAG_CREATE_PIPE) {
-        close(pipefd[PIPE_WRITE]);
-        if (0 == ret) // on success set FILE * pointer
-            if(fpp) *fpp = fp;
+    else {
+        // failure
+        netdata_popen_tracking_unlock();
+        error("POPEN: failed to spawn command: \"%s\" from parent pid %d.", command_to_be_logged, getpid());
+        ret = -1;
+        goto cleanup_and_return;
     }
 
-    if (!error) {
+    // the normal cleanup will run
+    // but ret == 0 at this point
+
+cleanup_and_return:
+    if(!attr_rc) {
         // posix_spawnattr_init() succeeded
         if (posix_spawnattr_destroy(&attr))
-            error("posix_spawnattr_destroy");
+            error("POPEN: posix_spawnattr_destroy() failed");
     }
+
     if (posix_spawn_file_actions_destroy(&fa))
-        error("posix_spawn_file_actions_destroy");
+        error("POPEN: posix_spawn_file_actions_destroy() failed");
 
-    return ret;
+    // the child end - close it
+    if(pipefd_stdin[PIPE_READ] != -1)
+        close(pipefd_stdin[PIPE_READ]);
 
-error_after_posix_spawn_file_actions_init:
-    if (posix_spawn_file_actions_destroy(&fa))
-        error("posix_spawn_file_actions_destroy");
+    // our end
+    if(ret == -1 || !fpp_child_stdin) {
+        if (fp_child_stdin)
+            fclose(fp_child_stdin);
+        else if (pipefd_stdin[PIPE_WRITE] != -1)
+            close(pipefd_stdin[PIPE_WRITE]);
+
+        fp_child_stdin = NULL;
+    }
+
+    // the child end - close it
+    if (pipefd_stdout[PIPE_WRITE] != -1)
+        close(pipefd_stdout[PIPE_WRITE]);
 
-error_after_pipe:
-    if (flags & POPEN_FLAG_CREATE_PIPE) {
-        if (fp)
-            fclose(fp);
-        else
-            close(pipefd[PIPE_READ]);
+    // our end
+    if (ret == -1 || !fpp_child_stdout) {
+        if (fp_child_stdout)
+            fclose(fp_child_stdout);
+        else if (pipefd_stdout[PIPE_READ] != -1)
+            close(pipefd_stdout[PIPE_READ]);
 
-        close(pipefd[PIPE_WRITE]);
+        fp_child_stdout = NULL;
     }
-    return -1;
+
+set_return_values_and_return:
+    if(fpp_child_stdin)
+        *fpp_child_stdin = fp_child_stdin;
+
+    if(fpp_child_stdout)
+        *fpp_child_stdout = fp_child_stdout;
+
+    return ret;
 }
 
-int custom_popene_variadic_internal_dont_use_directly(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp, const char *command, ...) {
+int netdata_popene_variadic_internal_dont_use_directly(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp_child_input, FILE **fpp_child_output, const char *command, ...) {
     // convert the variable list arguments into what posix_spawn() needs
     // all arguments are expected strings
     va_list args;
@@ -232,88 +353,34 @@ int custom_popene_variadic_internal_dont_use_directly(volatile pid_t *pidptr, ch
         va_end(args);
     }
 
-    return custom_popene(pidptr, env, flags, fpp, command, spawn_argv);
+    return popene_internal(pidptr, env, flags, fpp_child_input, fpp_child_output, command, spawn_argv);
 }
 
 // See man environ
 extern char **environ;
 
-// myp_init should be called by apps which act as init
-// (pid 1) so that processes created by mypopen and mypopene
-// are tracked. This enables the reaper to ignore processes
-// which will be handled internally, by calling myp_reap, to
-// avoid issues with already reaped processes during wait calls.
-//
-// Callers should call myp_free() to clean up resources.
-void myp_init(void) {
-    info("process tracking enabled.");
-    myp_tracking = 1;
-
-    if (netdata_mutex_init(&myp_lock) != 0) {
-	fatal("myp_init() mutex init failed.");
-    }
-}
-
-// myp_free cleans up any resources allocated for process
-// tracking.
-void myp_free(void) {
-    struct mypopen *mp, *next;
-
-    if (myp_tracking == 0)
-        return;
-
-    netdata_mutex_lock(&myp_lock);
-    for (mp = mypopen_root; mp != NULL; mp = next) {
-        next = mp->next;
-        freez(mp);
-    }
-
-    mypopen_root = NULL;
-    myp_tracking = 0;
-    netdata_mutex_unlock(&myp_lock);
-}
-
-// myp_reap returns 1 if pid should be reaped, 0 otherwise.
-int myp_reap(pid_t pid) {
-    struct mypopen *mp;
-
-    if (myp_tracking == 0)
-        return 0;
-
-    netdata_mutex_lock(&myp_lock);
-    for (mp = mypopen_root; mp != NULL; mp = mp->next) {
-        if (mp->pid == pid) {
-            netdata_mutex_unlock(&myp_lock);
-            return 0;
-        }
-    }
-    netdata_mutex_unlock(&myp_lock);
-
-    return 1;
-}
-
-FILE *mypopen(const char *command, volatile pid_t *pidptr) {
-    FILE *fp = NULL;
+FILE *netdata_popen(const char *command, volatile pid_t *pidptr, FILE **fpp_child_input) {
+    FILE *fp_child_output = NULL;
     const char *spawn_argv[] = {
         "sh",
         "-c",
         command,
         NULL
     };
-    (void)custom_popene(pidptr, environ, POPEN_FLAG_CREATE_PIPE|POPEN_FLAG_CLOSE_FD, &fp, "/bin/sh", spawn_argv);
-    return fp;
+    (void)popene_internal(pidptr, environ, POPEN_FLAG_CLOSE_FD, fpp_child_input, &fp_child_output, "/bin/sh", spawn_argv);
+    return fp_child_output;
 }
 
-FILE *mypopene(const char *command, volatile pid_t *pidptr, char **env) {
-    FILE *fp = NULL;
+FILE *netdata_popene(const char *command, volatile pid_t *pidptr, char **env, FILE **fpp_child_input) {
+    FILE *fp_child_output = NULL;
     const char *spawn_argv[] = {
         "sh",
         "-c",
         command,
         NULL
     };
-    (void)custom_popene( pidptr, env, POPEN_FLAG_CREATE_PIPE|POPEN_FLAG_CLOSE_FD, &fp, "/bin/sh", spawn_argv);
-    return fp;
+    (void)popene_internal(pidptr, env, POPEN_FLAG_CLOSE_FD, fpp_child_input, &fp_child_output, "/bin/sh", spawn_argv);
+    return fp_child_output;
 }
 
 // returns 0 on success, -1 on failure
@@ -324,29 +391,25 @@ int netdata_spawn(const char *command, volatile pid_t *pidptr) {
         command,
         NULL
     };
-    return custom_popene( pidptr, environ, POPEN_FLAG_NONE, NULL, "/bin/sh", spawn_argv);
+    return popene_internal(pidptr, environ, POPEN_FLAG_NONE, NULL, NULL, "/bin/sh", spawn_argv);
 }
 
-int custom_pclose(FILE *fp, pid_t pid) {
+int netdata_pclose(FILE *fp_child_input, FILE *fp_child_output, pid_t pid) {
     int ret;
     siginfo_t info;
 
-    debug(D_EXIT, "Request to mypclose() on pid %d", pid);
+    debug(D_EXIT, "Request to netdata_pclose() on pid %d", pid);
 
-    if (fp) {
-        // close the pipe fd
-        // this is required in musl
-        // without it the childs do not exit
-        close(fileno(fp));
+    if (fp_child_input)
+        fclose(fp_child_input);
 
-        // close the pipe file pointer
-        fclose(fp);
-    }
+    if (fp_child_output)
+        fclose(fp_child_output);
 
     errno = 0;
 
     ret = waitid(P_PID, (id_t) pid, &info, WEXITED);
-    myp_del(pid);
+    netdata_popen_tracking_del_pid(pid);
 
     if (ret != -1) {
         switch (info.si_code) {
@@ -392,12 +455,6 @@ int custom_pclose(FILE *fp, pid_t pid) {
     return 0;
 }
 
-int mypclose(FILE *fp, pid_t pid)
-{
-    return custom_pclose(fp, pid);
-}
-
-int netdata_spawn_waitpid(pid_t pid)
-{
-    return custom_pclose(NULL, pid);
+int netdata_spawn_waitpid(pid_t pid) {
+    return netdata_pclose(NULL, NULL, pid);
 }
diff --git a/libnetdata/popen/popen.h b/libnetdata/popen/popen.h
index 57eb9131e..c57a35a4e 100644
--- a/libnetdata/popen/popen.h
+++ b/libnetdata/popen/popen.h
@@ -10,31 +10,31 @@
 
 /* custom_popene_variadic_internal_dont_use_directly flag definitions */
 #define POPEN_FLAG_NONE        0
-#define POPEN_FLAG_CREATE_PIPE 1 // Create a pipe like popen() when set, otherwise set stdout to /dev/null
-#define POPEN_FLAG_CLOSE_FD    2 // Close all file descriptors other than STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO
+#define POPEN_FLAG_CLOSE_FD    (1 << 0) // Close all file descriptors other than STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO
 
 // the flags to be used by default
-#define POPEN_FLAGS_DEFAULT (POPEN_FLAG_CREATE_PIPE|POPEN_FLAG_CLOSE_FD)
+#define POPEN_FLAGS_DEFAULT (POPEN_FLAG_CLOSE_FD)
 
 // mypopen_raw is the interface to use instead of custom_popene_variadic_internal_dont_use_directly()
 // mypopen_raw will add the terminating NULL at the arguments list
 // we append the parameter 'command' twice - this is because the underlying call needs the command to execute and the argv[0] to pass to it
-#define mypopen_raw_default_flags_and_environment(pidptr, fpp, command, args...) custom_popene_variadic_internal_dont_use_directly(pidptr, environ, POPEN_FLAGS_DEFAULT, fpp, command, command, ##args, NULL)
-#define mypopen_raw_default_flags(pidptr, env, fpp, command, args...) custom_popene_variadic_internal_dont_use_directly(pidptr, env, POPEN_FLAGS_DEFAULT, fpp, command, command, ##args, NULL)
-#define mypopen_raw(pidptr, env, flags, fpp, command, args...) custom_popene_variadic_internal_dont_use_directly(pidptr, env, flags, fpp, command, command, ##args, NULL)
-
-extern int custom_popene_variadic_internal_dont_use_directly(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp, const char *command, ...);
-
-extern FILE *mypopen(const char *command, volatile pid_t *pidptr);
-extern FILE *mypopene(const char *command, volatile pid_t *pidptr, char **env);
-extern int mypclose(FILE *fp, pid_t pid);
-extern int netdata_spawn(const char *command, volatile pid_t *pidptr);
-extern int netdata_spawn_waitpid(pid_t pid);
-extern void myp_init(void);
-extern void myp_free(void);
-extern int myp_reap(pid_t pid);
-
-extern void signals_unblock(void);
-extern void signals_reset(void);
+#define netdata_popen_raw_default_flags_and_environment(pidptr, fpp_child_input, fpp_child_output, command, args...) netdata_popene_variadic_internal_dont_use_directly(pidptr, environ, POPEN_FLAGS_DEFAULT, fpp_child_input, fpp_child_output, command, command, ##args, NULL)
+#define netdata_popen_raw_default_flags(pidptr, env, fpp_child_input, fpp_child_output, command, args...) netdata_popene_variadic_internal_dont_use_directly(pidptr, env, POPEN_FLAGS_DEFAULT, fpp_child_input, fpp_child_output, command, command, ##args, NULL)
+#define netdata_popen_raw(pidptr, env, flags, fpp_child_input, fpp_child_output, command, args...) netdata_popene_variadic_internal_dont_use_directly(pidptr, env, flags, fpp_child_input, fpp_child_output, command, command, ##args, NULL)
+
+FILE *netdata_popen(const char *command, volatile pid_t *pidptr, FILE **fp_child_input);
+FILE *netdata_popene(const char *command, volatile pid_t *pidptr, char **env, FILE **fp_child_input);
+int netdata_popene_variadic_internal_dont_use_directly(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp_child_input, FILE **fpp_child_output, const char *command, ...);
+int netdata_pclose(FILE *fp_child_input, FILE *fp_child_output, pid_t pid);
+
+int netdata_spawn(const char *command, volatile pid_t *pidptr);
+int netdata_spawn_waitpid(pid_t pid);
+
+void netdata_popen_tracking_init(void);
+void netdata_popen_tracking_cleanup(void);
+int netdata_popen_tracking_pid_shoud_be_reaped(pid_t pid);
+
+void signals_unblock(void);
+void signals_reset(void);
 
 #endif /* NETDATA_POPEN_H */
diff --git a/libnetdata/procfile/procfile.c b/libnetdata/procfile/procfile.c
index 19964da17..b4ca025ec 100644
--- a/libnetdata/procfile/procfile.c
+++ b/libnetdata/procfile/procfile.c
@@ -42,7 +42,7 @@ char *procfile_filename(procfile *ff) {
 // ----------------------------------------------------------------------------
 // An array of words
 
-static inline void pfwords_add(procfile *ff, char *str) {
+static inline void procfile_words_add(procfile *ff, char *str) {
     // debug(D_PROCFILE, PF_PREFIX ":   adding word No %d: '%s'", fw->len, str);
 
     pfwords *fw = ff->words;
@@ -60,7 +60,7 @@ static inline void pfwords_add(procfile *ff, char *str) {
 }
 
 NEVERNULL
-static inline pfwords *pfwords_new(void) {
+static inline pfwords *procfile_words_create(void) {
     // debug(D_PROCFILE, PF_PREFIX ":   initializing words");
 
     size_t size = (procfile_adaptive_initial_allocation) ? procfile_max_words : PFWORDS_INCREASE_STEP;
@@ -71,12 +71,12 @@ static inline pfwords *pfwords_new(void) {
     return new;
 }
 
-static inline void pfwords_reset(pfwords *fw) {
+static inline void procfile_words_reset(pfwords *fw) {
     // debug(D_PROCFILE, PF_PREFIX ":   resetting words");
     fw->len = 0;
 }
 
-static inline void pfwords_free(pfwords *fw) {
+static inline void procfile_words_free(pfwords *fw) {
     // debug(D_PROCFILE, PF_PREFIX ":   freeing words");
 
     freez(fw);
@@ -87,7 +87,7 @@ static inline void pfwords_free(pfwords *fw) {
 // An array of lines
 
 NEVERNULL
-static inline size_t *pflines_add(procfile *ff) {
+static inline size_t *procfile_lines_add(procfile *ff) {
     // debug(D_PROCFILE, PF_PREFIX ":   adding line %d at word %d", fl->len, first_word);
 
     pflines *fl = ff->lines;
@@ -109,7 +109,7 @@ static inline size_t *pflines_add(procfile *ff) {
 }
 
 NEVERNULL
-static inline pflines *pflines_new(void) {
+static inline pflines *procfile_lines_create(void) {
     // debug(D_PROCFILE, PF_PREFIX ":   initializing lines");
 
     size_t size = (unlikely(procfile_adaptive_initial_allocation)) ? procfile_max_words : PFLINES_INCREASE_STEP;
@@ -120,13 +120,13 @@ static inline pflines *pflines_new(void) {
     return new;
 }
 
-static inline void pflines_reset(pflines *fl) {
+static inline void procfile_lines_reset(pflines *fl) {
     // debug(D_PROCFILE, PF_PREFIX ":   resetting lines");
 
     fl->len = 0;
 }
 
-static inline void pflines_free(pflines *fl) {
+static inline void procfile_lines_free(pflines *fl) {
     // debug(D_PROCFILE, PF_PREFIX ":   freeing lines");
 
     freez(fl);
@@ -141,8 +141,8 @@ void procfile_close(procfile *ff) {
 
     debug(D_PROCFILE, PF_PREFIX ": Closing file '%s'", procfile_filename(ff));
 
-    if(likely(ff->lines)) pflines_free(ff->lines);
-    if(likely(ff->words)) pfwords_free(ff->words);
+    if(likely(ff->lines)) procfile_lines_free(ff->lines);
+    if(likely(ff->words)) procfile_words_free(ff->words);
 
     if(likely(ff->fd != -1)) close(ff->fd);
     freez(ff);
@@ -162,7 +162,7 @@ static void procfile_parser(procfile *ff) {
     char quote = 0;                     // the quote character - only when in quoted string
     size_t opened = 0;                  // counts the number of open parenthesis
 
-    size_t *line_words = pflines_add(ff);
+    size_t *line_words = procfile_lines_add(ff);
 
     while(s < e) {
         PF_CHAR_TYPE ct = separators[(unsigned char)(*s)];
@@ -177,7 +177,7 @@ static void procfile_parser(procfile *ff) {
                 if (s != t) {
                     // separator, but we have word before it
                     *s = '\0';
-                    pfwords_add(ff, t);
+                    procfile_words_add(ff, t);
                     (*line_words)++;
                     t = ++s;
                 }
@@ -196,13 +196,13 @@ static void procfile_parser(procfile *ff) {
             // end of line
 
             *s = '\0';
-            pfwords_add(ff, t);
+            procfile_words_add(ff, t);
             (*line_words)++;
             t = ++s;
 
             // debug(D_PROCFILE, PF_PREFIX ":   ended line %d with %d words", l, ff->lines->lines[l].words);
 
-            line_words = pflines_add(ff);
+            line_words = procfile_lines_add(ff);
         }
         else if(likely(ct == PF_CHAR_IS_QUOTE)) {
             if(unlikely(!quote && s == t)) {
@@ -215,7 +215,7 @@ static void procfile_parser(procfile *ff) {
                 quote = 0;
 
                 *s = '\0';
-                pfwords_add(ff, t);
+                procfile_words_add(ff, t);
                 (*line_words)++;
                 t = ++s;
             }
@@ -240,7 +240,7 @@ static void procfile_parser(procfile *ff) {
 
                 if(!opened) {
                     *s = '\0';
-                    pfwords_add(ff, t);
+                    procfile_words_add(ff, t);
                     (*line_words)++;
                     t = ++s;
                 }
@@ -262,7 +262,7 @@ static void procfile_parser(procfile *ff) {
         }
 
         *s = '\0';
-        pfwords_add(ff, t);
+        procfile_words_add(ff, t);
         (*line_words)++;
         // t = ++s;
     }
@@ -305,8 +305,8 @@ procfile *procfile_readall(procfile *ff) {
         return NULL;
     }
 
-    pflines_reset(ff->lines);
-    pfwords_reset(ff->words);
+    procfile_lines_reset(ff->lines);
+    procfile_words_reset(ff->words);
     procfile_parser(ff);
 
     if(unlikely(procfile_adaptive_initial_allocation)) {
@@ -423,8 +423,8 @@ procfile *procfile_open(const char *filename, const char *separators, uint32_t f
     ff->len = 0;
     ff->flags = flags;
 
-    ff->lines = pflines_new();
-    ff->words = pfwords_new();
+    ff->lines = procfile_lines_create();
+    ff->words = procfile_words_create();
 
     procfile_set_separators(ff, separators);
 
diff --git a/libnetdata/procfile/procfile.h b/libnetdata/procfile/procfile.h
index 5263ad770..5d45e4028 100644
--- a/libnetdata/procfile/procfile.h
+++ b/libnetdata/procfile/procfile.h
@@ -60,25 +60,25 @@ typedef struct {
 } procfile;
 
 // close the proc file and free all related memory
-extern void procfile_close(procfile *ff);
+void procfile_close(procfile *ff);
 
 // (re)read and parse the proc file
-extern procfile *procfile_readall(procfile *ff);
+procfile *procfile_readall(procfile *ff);
 
 // open a /proc or /sys file
-extern procfile *procfile_open(const char *filename, const char *separators, uint32_t flags);
+procfile *procfile_open(const char *filename, const char *separators, uint32_t flags);
 
 // re-open a file
 // if separators == NULL, the last separators are used
-extern procfile *procfile_reopen(procfile *ff, const char *filename, const char *separators, uint32_t flags);
+procfile *procfile_reopen(procfile *ff, const char *filename, const char *separators, uint32_t flags);
 
 // example walk-through a procfile parsed file
-extern void procfile_print(procfile *ff);
+void procfile_print(procfile *ff);
 
-extern void procfile_set_quotes(procfile *ff, const char *quotes);
-extern void procfile_set_open_close(procfile *ff, const char *open, const char *close);
+void procfile_set_quotes(procfile *ff, const char *quotes);
+void procfile_set_open_close(procfile *ff, const char *open, const char *close);
 
-extern char *procfile_filename(procfile *ff);
+char *procfile_filename(procfile *ff);
 
 // ----------------------------------------------------------------------------
 
diff --git a/libnetdata/required_dummies.h b/libnetdata/required_dummies.h
index 6d51bfedd..ad1e8fb84 100644
--- a/libnetdata/required_dummies.h
+++ b/libnetdata/required_dummies.h
@@ -22,15 +22,20 @@ void signals_block(void){};
 void signals_unblock(void){};
 void signals_reset(void){};
 
+#ifndef UNIT_TESTING
 // callback required by eval()
-int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, NETDATA_DOUBLE *result)
+int health_variable_lookup(STRING *variable, struct rrdcalc *rc, NETDATA_DOUBLE *result)
 {
     (void)variable;
-    (void)hash;
     (void)rc;
     (void)result;
     return 0;
 };
+#endif
+
+void rrdset_thread_rda_free(void){};
+void sender_thread_buffer_free(void){};
+void query_target_free(void){};
 
 // required by get_system_cpus()
 char *netdata_configured_host_prefix = "";
diff --git a/libnetdata/simple_pattern/simple_pattern.c b/libnetdata/simple_pattern/simple_pattern.c
index 70b06a22b..81c2ed0b8 100644
--- a/libnetdata/simple_pattern/simple_pattern.c
+++ b/libnetdata/simple_pattern/simple_pattern.c
@@ -333,9 +333,7 @@ extern int simple_pattern_is_potential_name(SIMPLE_PATTERN *p)
 }
 
 char *simple_pattern_trim_around_equal(char *src) {
-    char *store = mallocz(strlen(src) +1);
-    if(!store)
-        return NULL;
+    char *store = mallocz(strlen(src) + 1);
 
     char *dst = store;
     while (*src) {
diff --git a/libnetdata/simple_pattern/simple_pattern.h b/libnetdata/simple_pattern/simple_pattern.h
index 36fbbde7d..7282053e8 100644
--- a/libnetdata/simple_pattern/simple_pattern.h
+++ b/libnetdata/simple_pattern/simple_pattern.h
@@ -18,23 +18,25 @@ typedef void SIMPLE_PATTERN;
 // create a simple_pattern from the string given
 // default_mode is used in cases where EXACT matches, without an asterisk,
 // should be considered PREFIX matches.
-extern SIMPLE_PATTERN *simple_pattern_create(const char *list, const char *separators, SIMPLE_PREFIX_MODE default_mode);
+SIMPLE_PATTERN *simple_pattern_create(const char *list, const char *separators, SIMPLE_PREFIX_MODE default_mode);
 
 // test if string str is matched from the pattern and fill 'wildcarded' with the parts matched by '*'
-extern int simple_pattern_matches_extract(SIMPLE_PATTERN *list, const char *str, char *wildcarded, size_t wildcarded_size);
+int simple_pattern_matches_extract(SIMPLE_PATTERN *list, const char *str, char *wildcarded, size_t wildcarded_size);
 
 // test if string str is matched from the pattern
 #define simple_pattern_matches(list, str) simple_pattern_matches_extract(list, str, NULL, 0)
 
 // free a simple_pattern that was created with simple_pattern_create()
 // list can be NULL, in which case, this does nothing.
-extern void simple_pattern_free(SIMPLE_PATTERN *list);
+void simple_pattern_free(SIMPLE_PATTERN *list);
 
-extern void simple_pattern_dump(uint64_t debug_type, SIMPLE_PATTERN *p) ;
-extern int simple_pattern_is_potential_name(SIMPLE_PATTERN *p) ;
-extern char *simple_pattern_iterate(SIMPLE_PATTERN **p);
+void simple_pattern_dump(uint64_t debug_type, SIMPLE_PATTERN *p) ;
+int simple_pattern_is_potential_name(SIMPLE_PATTERN *p) ;
+char *simple_pattern_iterate(SIMPLE_PATTERN **p);
 
-//Auxiliary function to create a pattern
+// Auxiliary function to create a pattern
 char *simple_pattern_trim_around_equal(char *src);
 
+#define is_valid_sp(x) ((x) && *(x) && !((x)[0] == '*' && (x)[1] == '\0'))
+
 #endif //NETDATA_SIMPLE_PATTERN_H
diff --git a/libnetdata/socket/security.c b/libnetdata/socket/security.c
index 6ac512de5..f7b44049b 100644
--- a/libnetdata/socket/security.c
+++ b/libnetdata/socket/security.c
@@ -2,14 +2,14 @@
 
 #ifdef ENABLE_HTTPS
 
-SSL_CTX *netdata_exporting_ctx=NULL;
-SSL_CTX *netdata_client_ctx=NULL;
-SSL_CTX *netdata_srv_ctx=NULL;
-const char *security_key=NULL;
-const char *security_cert=NULL;
+SSL_CTX *netdata_ssl_exporting_ctx =NULL;
+SSL_CTX *netdata_ssl_client_ctx =NULL;
+SSL_CTX *netdata_ssl_srv_ctx =NULL;
+const char *netdata_ssl_security_key =NULL;
+const char *netdata_ssl_security_cert =NULL;
 const char *tls_version=NULL;
 const char *tls_ciphers=NULL;
-int netdata_validate_server =  NETDATA_SSL_VALID_CERTIFICATE;
+int netdata_ssl_validate_server =  NETDATA_SSL_VALID_CERTIFICATE;
 
 /**
  * Info Callback
@@ -161,7 +161,7 @@ static SSL_CTX * security_initialize_openssl_server() {
         return NULL;
     }
 
-    SSL_CTX_use_certificate_file(ctx, security_cert, SSL_FILETYPE_PEM);
+    SSL_CTX_use_certificate_file(ctx, netdata_ssl_security_cert, SSL_FILETYPE_PEM);
 #else
     ctx = SSL_CTX_new(TLS_server_method());
     if (!ctx) {
@@ -169,11 +169,11 @@ static SSL_CTX * security_initialize_openssl_server() {
         return NULL;
     }
 
-    SSL_CTX_use_certificate_chain_file(ctx, security_cert);
+    SSL_CTX_use_certificate_chain_file(ctx, netdata_ssl_security_cert);
 #endif
     security_openssl_common_options(ctx, 0);
 
-    SSL_CTX_use_PrivateKey_file(ctx,security_key,SSL_FILETYPE_PEM);
+    SSL_CTX_use_PrivateKey_file(ctx, netdata_ssl_security_key,SSL_FILETYPE_PEM);
 
     if (!SSL_CTX_check_private_key(ctx)) {
         ERR_error_string_n(ERR_get_error(),lerror,sizeof(lerror));
@@ -207,24 +207,25 @@ void security_start_ssl(int selector) {
     switch (selector) {
         case NETDATA_SSL_CONTEXT_SERVER: {
             struct stat statbuf;
-            if (stat(security_key, &statbuf) || stat(security_cert, &statbuf)) {
+            if (stat(netdata_ssl_security_key, &statbuf) || stat(netdata_ssl_security_cert, &statbuf)) {
                 info("To use encryption it is necessary to set \"ssl certificate\" and \"ssl key\" in [web] !\n");
                 return;
             }
 
-            netdata_srv_ctx =  security_initialize_openssl_server();
-            SSL_CTX_set_mode(netdata_srv_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
+            netdata_ssl_srv_ctx =  security_initialize_openssl_server();
+            SSL_CTX_set_mode(netdata_ssl_srv_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
             break;
         }
         case NETDATA_SSL_CONTEXT_STREAMING: {
-            netdata_client_ctx = security_initialize_openssl_client();
+            netdata_ssl_client_ctx = security_initialize_openssl_client();
             //This is necessary for the stream, because it is working sometimes with nonblock socket.
             //It returns the bitmask after to change, there is not any description of errors in the documentation
-            SSL_CTX_set_mode(netdata_client_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE |SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |SSL_MODE_AUTO_RETRY);
+            SSL_CTX_set_mode(
+                netdata_ssl_client_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE |SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |SSL_MODE_AUTO_RETRY);
             break;
         }
         case NETDATA_SSL_CONTEXT_EXPORTING: {
-            netdata_exporting_ctx = security_initialize_openssl_client();
+            netdata_ssl_exporting_ctx = security_initialize_openssl_client();
             break;
         }
     }
@@ -237,16 +238,16 @@ void security_start_ssl(int selector) {
  */
 void security_clean_openssl()
 {
-    if (netdata_srv_ctx) {
-        SSL_CTX_free(netdata_srv_ctx);
+    if (netdata_ssl_srv_ctx) {
+        SSL_CTX_free(netdata_ssl_srv_ctx);
     }
 
-    if (netdata_client_ctx) {
-        SSL_CTX_free(netdata_client_ctx);
+    if (netdata_ssl_client_ctx) {
+        SSL_CTX_free(netdata_ssl_client_ctx);
     }
 
-    if (netdata_exporting_ctx) {
-        SSL_CTX_free(netdata_exporting_ctx);
+    if (netdata_ssl_exporting_ctx) {
+        SSL_CTX_free(netdata_ssl_exporting_ctx);
     }
 
 #if OPENSSL_VERSION_NUMBER < OPENSSL_VERSION_110
@@ -355,32 +356,23 @@ int security_test_certificate(SSL *ssl) {
  *
  * @return It returns 0 on success and -1 otherwise.
  */
-int security_location_for_context(SSL_CTX *ctx, char *file, char *path) {
-    struct stat statbuf;
-    if (stat(file, &statbuf)) {
-        info("Netdata does not have the parent's SSL certificate, so it will use the default OpenSSL configuration to validate certificates!");
-        return 0;
-    }
-
-    ERR_clear_error();
-    u_long err;
-    char buf[256];
-    if(!SSL_CTX_load_verify_locations(ctx, file, path)) {
-        goto slfc;
+int ssl_security_location_for_context(SSL_CTX *ctx, char *file, char *path) {
+    int load_custom = 1, load_default = 1;
+    if (file || path) {
+        if(!SSL_CTX_load_verify_locations(ctx, file, path)) {
+            info("Netdata can not verify custom CAfile or CApath for parent's SSL certificate, so it will use the default OpenSSL configuration to validate certificates!");
+            load_custom = 0;
+        }
     }
 
     if(!SSL_CTX_set_default_verify_paths(ctx)) {
-        goto slfc;
+        info("Can not verify default OpenSSL configuration to validate certificates!");
+        load_default = 0;
     }
 
-    return 0;
+    if (load_custom  == 0 && load_default == 0)
+        return -1;
 
-slfc:
-    while ((err = ERR_get_error()) != 0) {
-        ERR_error_string_n(err, buf, sizeof(buf));
-        error("Cannot set the directory for the certificates and the parent SSL certificate: %s",buf);
-    }
-    return -1;
+    return 0;
 }
-
 #endif
diff --git a/libnetdata/socket/security.h b/libnetdata/socket/security.h
index dbf71a6fe..ae7c595e3 100644
--- a/libnetdata/socket/security.h
+++ b/libnetdata/socket/security.h
@@ -37,20 +37,20 @@
 #include <openssl/decoder.h>
 #endif
 
-struct netdata_ssl{
+struct netdata_ssl {
     SSL *conn; //SSL connection
     uint32_t flags; //The flags for SSL connection
 };
 
-extern SSL_CTX *netdata_exporting_ctx;
-extern SSL_CTX *netdata_client_ctx;
-extern SSL_CTX *netdata_srv_ctx;
-extern const char *security_key;
-extern const char *security_cert;
+extern SSL_CTX *netdata_ssl_exporting_ctx;
+extern SSL_CTX *netdata_ssl_client_ctx;
+extern SSL_CTX *netdata_ssl_srv_ctx;
+extern const char *netdata_ssl_security_key;
+extern const char *netdata_ssl_security_cert;
 extern const char *tls_version;
 extern const char *tls_ciphers;
-extern int netdata_validate_server;
-extern int security_location_for_context(SSL_CTX *ctx,char *file,char *path);
+extern int netdata_ssl_validate_server;
+int ssl_security_location_for_context(SSL_CTX *ctx,char *file,char *path);
 
 void security_openssl_library();
 void security_clean_openssl();
diff --git a/libnetdata/socket/socket.c b/libnetdata/socket/socket.c
index df6d3148b..40271b623 100644
--- a/libnetdata/socket/socket.c
+++ b/libnetdata/socket/socket.c
@@ -779,6 +779,10 @@ int connect_to_this(const char *definition, int default_port, struct timeval *ti
         char *path = host + 5;
         return connect_to_unix(path, timeout);
     }
+    else if(*host == '/') {
+        char *path = host;
+        return connect_to_unix(path, timeout);
+    }
 
     char *e = host;
     if(*e == '[') {
@@ -826,43 +830,141 @@ int connect_to_this(const char *definition, int default_port, struct timeval *ti
     return connect_to_this_ip46(protocol, socktype, host, scope_id, service, timeout);
 }
 
-int connect_to_one_of(const char *destination, int default_port, struct timeval *timeout, size_t *reconnects_counter, char *connected_to, size_t connected_to_size) {
-    int sock = -1;
-
+void foreach_entry_in_connection_string(const char *destination, bool (*callback)(char *entry, void *data), void *data) {
     const char *s = destination;
     while(*s) {
         const char *e = s;
 
-        // skip path, moving both s(tart) and e(nd)
-        if(*e == '/')
-            while(!isspace(*e) && *e != ',') s = ++e;
-
         // skip separators, moving both s(tart) and e(nd)
         while(isspace(*e) || *e == ',') s = ++e;
 
         // move e(nd) to the first separator
-        while(*e && !isspace(*e) && *e != ',' && *e != '/') e++;
+        while(*e && !isspace(*e) && *e != ',') e++;
 
         // is there anything?
         if(!*s || s == e) break;
 
         char buf[e - s + 1];
         strncpyz(buf, s, e - s);
-        if(reconnects_counter) *reconnects_counter += 1;
-        sock = connect_to_this(buf, default_port, timeout);
-        if(sock != -1) {
-            if(connected_to && connected_to_size) {
-                strncpy(connected_to, buf, connected_to_size);
-                connected_to[connected_to_size - 1] = '\0';
-            }
-            break;
-        }
+
+        if(callback(buf, data)) break;
+
         s = e;
     }
+}
 
-    return sock;
+struct connect_to_one_of_data {
+    int default_port;
+    struct timeval *timeout;
+    size_t *reconnects_counter;
+    char *connected_to;
+    size_t connected_to_size;
+    int sock;
+};
+
+static bool connect_to_one_of_callback(char *entry, void *data) {
+    struct connect_to_one_of_data *t = data;
+
+    if(t->reconnects_counter)
+        t->reconnects_counter++;
+
+    t->sock = connect_to_this(entry, t->default_port, t->timeout);
+    if(t->sock != -1) {
+        if(t->connected_to && t->connected_to_size) {
+            strncpyz(t->connected_to, entry, t->connected_to_size);
+            t->connected_to[t->connected_to_size - 1] = '\0';
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+int connect_to_one_of(const char *destination, int default_port, struct timeval *timeout, size_t *reconnects_counter, char *connected_to, size_t connected_to_size) {
+    struct connect_to_one_of_data t = {
+        .default_port = default_port,
+        .timeout = timeout,
+        .reconnects_counter = reconnects_counter,
+        .connected_to = connected_to,
+        .connected_to_size = connected_to_size,
+        .sock = -1,
+    };
+
+    foreach_entry_in_connection_string(destination, connect_to_one_of_callback, &t);
+
+    return t.sock;
+}
+
+static bool connect_to_one_of_urls_callback(char *entry, void *data) {
+    char *s = strchr(entry, '/');
+    if(s) *s = '\0';
+
+    return connect_to_one_of_callback(entry, data);
 }
 
+int connect_to_one_of_urls(const char *destination, int default_port, struct timeval *timeout, size_t *reconnects_counter, char *connected_to, size_t connected_to_size) {
+    struct connect_to_one_of_data t = {
+        .default_port = default_port,
+        .timeout = timeout,
+        .reconnects_counter = reconnects_counter,
+        .connected_to = connected_to,
+        .connected_to_size = connected_to_size,
+        .sock = -1,
+    };
+
+    foreach_entry_in_connection_string(destination, connect_to_one_of_urls_callback, &t);
+
+    return t.sock;
+}
+
+
+#ifdef ENABLE_HTTPS
+ssize_t netdata_ssl_read(SSL *ssl, void *buf, size_t num) {
+    error_limit_static_thread_var(erl, 1, 0);
+
+    int bytes, err, retries = 0;
+
+    //do {
+        bytes = SSL_read(ssl, buf, (int)num);
+        err = SSL_get_error(ssl, bytes);
+        retries++;
+    //} while (bytes <= 0 && (err == SSL_ERROR_WANT_READ));
+
+    if(unlikely(bytes <= 0))
+        error("SSL_read() returned %d bytes, SSL error %d", bytes, err);
+
+    if(retries > 1)
+        error_limit(&erl, "SSL_read() retried %d times", retries);
+
+    return bytes;
+}
+
+ssize_t netdata_ssl_write(SSL *ssl, const void *buf, size_t num) {
+    error_limit_static_thread_var(erl, 1, 0);
+
+    int bytes, err, retries = 0;
+    size_t total = 0;
+
+    //do {
+        bytes = SSL_write(ssl, (uint8_t *)buf + total, (int)(num - total));
+        err = SSL_get_error(ssl, bytes);
+        retries++;
+
+        if(bytes > 0)
+            total += bytes;
+
+    //} while ((bytes <= 0 && (err == SSL_ERROR_WANT_WRITE)) || (bytes > 0 && total < num));
+
+    if(unlikely(bytes <= 0))
+        error("SSL_write() returned %d bytes, SSL error %d", bytes, err);
+
+    if(retries > 1)
+        error_limit(&erl, "SSL_write() retried %d times", retries);
+
+    return bytes;
+}
+#endif
 
 // --------------------------------------------------------------------------------------------------------------------
 // helpers to send/receive data in one call, in blocking mode, with a timeout
@@ -901,12 +1003,10 @@ ssize_t recv_timeout(int sockfd, void *buf, size_t len, int flags, int timeout)
     }
 
 #ifdef ENABLE_HTTPS
-    if (ssl->conn) {
-        if (!ssl->flags) {
-            return SSL_read(ssl->conn,buf,len);
-        }
-    }
+    if (ssl->conn && ssl->flags == NETDATA_SSL_HANDSHAKE_COMPLETE)
+        return netdata_ssl_read(ssl->conn, buf, len);
 #endif
+
     return recv(sockfd, buf, len, flags);
 }
 
@@ -945,8 +1045,12 @@ ssize_t send_timeout(int sockfd, void *buf, size_t len, int flags, int timeout)
 
 #ifdef ENABLE_HTTPS
     if(ssl->conn) {
-        if (!ssl->flags) {
-            return SSL_write(ssl->conn, buf, len);
+        if (ssl->flags == NETDATA_SSL_HANDSHAKE_COMPLETE) {
+            return netdata_ssl_write(ssl->conn, buf, len);
+        }
+        else {
+            error("cannot write to SSL connection - connection is not ready.");
+            return -1;
         }
     }
 #endif
@@ -1087,12 +1191,11 @@ int accept_socket(int fd, int flags, char *client_ip, size_t ipsize, char *clien
         if (getnameinfo((struct sockaddr *)&sadr, addrlen, client_ip, (socklen_t)ipsize,
                         client_port, (socklen_t)portsize, NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
             error("LISTENER: cannot getnameinfo() on received client connection.");
-            strncpyz(client_ip, "UNKNOWN", ipsize - 1);
-            strncpyz(client_port, "UNKNOWN", portsize - 1);
+            strncpyz(client_ip, "UNKNOWN", ipsize);
+            strncpyz(client_port, "UNKNOWN", portsize);
         }
         if (!strcmp(client_ip, "127.0.0.1") || !strcmp(client_ip, "::1")) {
-            strncpy(client_ip, "localhost", ipsize);
-            client_ip[ipsize - 1] = '\0';
+            strncpyz(client_ip, "localhost", ipsize);
         }
 
 #ifdef __FreeBSD__
@@ -1107,8 +1210,7 @@ int accept_socket(int fd, int flags, char *client_ip, size_t ipsize, char *clien
             case AF_UNIX:
                 debug(D_LISTENER, "New UNIX domain web client from %s on socket %d.", client_ip, fd);
                 // set the port - certain versions of libc return garbage on unix sockets
-                strncpy(client_port, "UNIX", portsize);
-                client_port[portsize - 1] = '\0';
+                strncpyz(client_port, "UNIX", portsize);
                 break;
 
             case AF_INET:
@@ -1490,8 +1592,9 @@ static int poll_process_new_tcp_connection(POLLJOB *p, POLLINFO *pi, struct poll
         debug(D_POLLFD, "POLLFD: LISTENER: accept4() slot %zu (fd %d) failed.", pi->slot, pf->fd);
 
         if(unlikely(errno == EMFILE)) {
-            error("POLLFD: LISTENER: too many open files - sleeping for 1ms - used by this thread %zu, max for this thread %zu", p->used, p->limit);
-            usleep(1000); // 1ms
+            error_limit_static_global_var(erl, 10, 1000);
+            error_limit(&erl, "POLLFD: LISTENER: too many open files - used by this thread %zu, max for this thread %zu",
+                      p->used, p->limit);
         }
         else if(unlikely(errno != EWOULDBLOCK && errno != EAGAIN))
             error("POLLFD: LISTENER: accept() failed.");
diff --git a/libnetdata/socket/socket.h b/libnetdata/socket/socket.h
index a40d801dd..282324273 100644
--- a/libnetdata/socket/socket.h
+++ b/libnetdata/socket/socket.h
@@ -10,19 +10,22 @@
 #endif
 
 typedef enum web_client_acl {
-    WEB_CLIENT_ACL_NONE        = 0,
-    WEB_CLIENT_ACL_NOCHECK     = 0,
-    WEB_CLIENT_ACL_DASHBOARD   = 1 << 0,
-    WEB_CLIENT_ACL_REGISTRY    = 1 << 1,
-    WEB_CLIENT_ACL_BADGE       = 1 << 2,
-    WEB_CLIENT_ACL_MGMT        = 1 << 3,
-    WEB_CLIENT_ACL_STREAMING   = 1 << 4,
-    WEB_CLIENT_ACL_NETDATACONF = 1 << 5,
+    WEB_CLIENT_ACL_NONE         = 0,
+    WEB_CLIENT_ACL_NOCHECK      = 0,
+    WEB_CLIENT_ACL_DASHBOARD    = 1 << 0,
+    WEB_CLIENT_ACL_REGISTRY     = 1 << 1,
+    WEB_CLIENT_ACL_BADGE        = 1 << 2,
+    WEB_CLIENT_ACL_MGMT         = 1 << 3,
+    WEB_CLIENT_ACL_STREAMING    = 1 << 4,
+    WEB_CLIENT_ACL_NETDATACONF  = 1 << 5,
     WEB_CLIENT_ACL_SSL_OPTIONAL = 1 << 6,
-    WEB_CLIENT_ACL_SSL_FORCE = 1 << 7,
-    WEB_CLIENT_ACL_SSL_DEFAULT = 1 << 8
+    WEB_CLIENT_ACL_SSL_FORCE    = 1 << 7,
+    WEB_CLIENT_ACL_SSL_DEFAULT  = 1 << 8,
+    WEB_CLIENT_ACL_ACLK         = 1 << 9,
 } WEB_CLIENT_ACL;
 
+#define WEB_CLIENT_ACL_ALL 0xFFFF
+
 #define web_client_can_access_dashboard(w) ((w)->acl & WEB_CLIENT_ACL_DASHBOARD)
 #define web_client_can_access_registry(w) ((w)->acl & WEB_CLIENT_ACL_REGISTRY)
 #define web_client_can_access_badges(w) ((w)->acl & WEB_CLIENT_ACL_BADGE)
@@ -49,37 +52,42 @@ typedef struct listen_sockets {
     WEB_CLIENT_ACL fds_acl_flags[MAX_LISTEN_FDS];  // the acl to apply to the open sockets (dashboard, badges, streaming, netdata.conf, management)
 } LISTEN_SOCKETS;
 
-extern char *strdup_client_description(int family, const char *protocol, const char *ip, uint16_t port);
+char *strdup_client_description(int family, const char *protocol, const char *ip, uint16_t port);
 
-extern int listen_sockets_setup(LISTEN_SOCKETS *sockets);
-extern void listen_sockets_close(LISTEN_SOCKETS *sockets);
+int listen_sockets_setup(LISTEN_SOCKETS *sockets);
+void listen_sockets_close(LISTEN_SOCKETS *sockets);
 
-extern int connect_to_this(const char *definition, int default_port, struct timeval *timeout);
-extern int connect_to_one_of(const char *destination, int default_port, struct timeval *timeout, size_t *reconnects_counter, char *connected_to, size_t connected_to_size);
+void foreach_entry_in_connection_string(const char *destination, bool (*callback)(char *entry, void *data), void *data);
 int connect_to_this_ip46(int protocol, int socktype, const char *host, uint32_t scope_id, const char *service, struct timeval *timeout);
+int connect_to_this(const char *definition, int default_port, struct timeval *timeout);
+int connect_to_one_of(const char *destination, int default_port, struct timeval *timeout, size_t *reconnects_counter, char *connected_to, size_t connected_to_size);
+int connect_to_one_of_urls(const char *destination, int default_port, struct timeval *timeout, size_t *reconnects_counter, char *connected_to, size_t connected_to_size);
+
 
 #ifdef ENABLE_HTTPS
-extern ssize_t recv_timeout(struct netdata_ssl *ssl,int sockfd, void *buf, size_t len, int flags, int timeout);
-extern ssize_t send_timeout(struct netdata_ssl *ssl,int sockfd, void *buf, size_t len, int flags, int timeout);
+ssize_t recv_timeout(struct netdata_ssl *ssl,int sockfd, void *buf, size_t len, int flags, int timeout);
+ssize_t send_timeout(struct netdata_ssl *ssl,int sockfd, void *buf, size_t len, int flags, int timeout);
+ssize_t netdata_ssl_read(SSL *ssl, void *buf, size_t num);
+ssize_t netdata_ssl_write(SSL *ssl, const void *buf, size_t num);
 #else
-extern ssize_t recv_timeout(int sockfd, void *buf, size_t len, int flags, int timeout);
-extern ssize_t send_timeout(int sockfd, void *buf, size_t len, int flags, int timeout);
+ssize_t recv_timeout(int sockfd, void *buf, size_t len, int flags, int timeout);
+ssize_t send_timeout(int sockfd, void *buf, size_t len, int flags, int timeout);
 #endif
 
-extern int sock_setnonblock(int fd);
-extern int sock_delnonblock(int fd);
-extern int sock_setreuse(int fd, int reuse);
-extern int sock_setreuse_port(int fd, int reuse);
-extern int sock_enlarge_in(int fd);
-extern int sock_enlarge_out(int fd);
+int sock_setnonblock(int fd);
+int sock_delnonblock(int fd);
+int sock_setreuse(int fd, int reuse);
+int sock_setreuse_port(int fd, int reuse);
+int sock_enlarge_in(int fd);
+int sock_enlarge_out(int fd);
 
-extern int connection_allowed(int fd, char *client_ip, char *client_host, size_t hostsize,
+int connection_allowed(int fd, char *client_ip, char *client_host, size_t hostsize,
                               SIMPLE_PATTERN *access_list, const char *patname, int allow_dns);
-extern int accept_socket(int fd, int flags, char *client_ip, size_t ipsize, char *client_port, size_t portsize,
+int accept_socket(int fd, int flags, char *client_ip, size_t ipsize, char *client_port, size_t portsize,
                          char *client_host, size_t hostsize, SIMPLE_PATTERN *access_list, int allow_dns);
 
 #ifndef HAVE_ACCEPT4
-extern int accept4(int sock, struct sockaddr *addr, socklen_t *addrlen, int flags);
+int accept4(int sock, struct sockaddr *addr, socklen_t *addrlen, int flags);
 
 #ifndef SOCK_NONBLOCK
 #define SOCK_NONBLOCK 00004000
@@ -167,12 +175,12 @@ struct poll {
 
 #define pollinfo_from_slot(p, slot) (&((p)->inf[(slot)]))
 
-extern int poll_default_snd_callback(POLLINFO *pi, short int *events);
-extern int poll_default_rcv_callback(POLLINFO *pi, short int *events);
-extern void poll_default_del_callback(POLLINFO *pi);
-extern void *poll_default_add_callback(POLLINFO *pi, short int *events, void *data);
+int poll_default_snd_callback(POLLINFO *pi, short int *events);
+int poll_default_rcv_callback(POLLINFO *pi, short int *events);
+void poll_default_del_callback(POLLINFO *pi);
+void *poll_default_add_callback(POLLINFO *pi, short int *events, void *data);
 
-extern POLLINFO *poll_add_fd(POLLJOB *p
+POLLINFO *poll_add_fd(POLLJOB *p
                              , int fd
                              , int socktype
                              , WEB_CLIENT_ACL port_acl
@@ -186,9 +194,9 @@ extern POLLINFO *poll_add_fd(POLLJOB *p
                              , int   (*snd_callback)(POLLINFO *pi, short int *events)
                              , void *data
 );
-extern void poll_close_fd(POLLINFO *pi);
+void poll_close_fd(POLLINFO *pi);
 
-extern void poll_events(LISTEN_SOCKETS *sockets
+void poll_events(LISTEN_SOCKETS *sockets
         , void *(*add_callback)(POLLINFO *pi, short int *events, void *data)
         , void  (*del_callback)(POLLINFO *pi)
         , int   (*rcv_callback)(POLLINFO *pi, short int *events)
diff --git a/libnetdata/statistical/statistical.h b/libnetdata/statistical/statistical.h
index 9496e0e7f..f3ecfadb4 100644
--- a/libnetdata/statistical/statistical.h
+++ b/libnetdata/statistical/statistical.h
@@ -5,30 +5,30 @@
 
 #include "../libnetdata.h"
 
-extern void log_series_to_stderr(NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE result, const char *msg);
+void log_series_to_stderr(NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE result, const char *msg);
 
-extern NETDATA_DOUBLE average(const NETDATA_DOUBLE *series, size_t entries);
-extern NETDATA_DOUBLE moving_average(const NETDATA_DOUBLE *series, size_t entries, size_t period);
-extern NETDATA_DOUBLE median(const NETDATA_DOUBLE *series, size_t entries);
-extern NETDATA_DOUBLE moving_median(const NETDATA_DOUBLE *series, size_t entries, size_t period);
-extern NETDATA_DOUBLE running_median_estimate(const NETDATA_DOUBLE *series, size_t entries);
-extern NETDATA_DOUBLE standard_deviation(const NETDATA_DOUBLE *series, size_t entries);
-extern NETDATA_DOUBLE single_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha);
+NETDATA_DOUBLE average(const NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE moving_average(const NETDATA_DOUBLE *series, size_t entries, size_t period);
+NETDATA_DOUBLE median(const NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE moving_median(const NETDATA_DOUBLE *series, size_t entries, size_t period);
+NETDATA_DOUBLE running_median_estimate(const NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE standard_deviation(const NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE single_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha);
 extern NETDATA_DOUBLE
 single_exponential_smoothing_reverse(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha);
-extern NETDATA_DOUBLE double_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries,
+NETDATA_DOUBLE double_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries,
     NETDATA_DOUBLE alpha,
     NETDATA_DOUBLE beta,
     NETDATA_DOUBLE *forecast);
-extern NETDATA_DOUBLE holtwinters(const NETDATA_DOUBLE *series, size_t entries,
+NETDATA_DOUBLE holtwinters(const NETDATA_DOUBLE *series, size_t entries,
     NETDATA_DOUBLE alpha,
     NETDATA_DOUBLE beta,
     NETDATA_DOUBLE gamma,
     NETDATA_DOUBLE *forecast);
-extern NETDATA_DOUBLE sum_and_count(const NETDATA_DOUBLE *series, size_t entries, size_t *count);
-extern NETDATA_DOUBLE sum(const NETDATA_DOUBLE *series, size_t entries);
-extern NETDATA_DOUBLE median_on_sorted_series(const NETDATA_DOUBLE *series, size_t entries);
-extern NETDATA_DOUBLE *copy_series(const NETDATA_DOUBLE *series, size_t entries);
-extern void sort_series(NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE sum_and_count(const NETDATA_DOUBLE *series, size_t entries, size_t *count);
+NETDATA_DOUBLE sum(const NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE median_on_sorted_series(const NETDATA_DOUBLE *series, size_t entries);
+NETDATA_DOUBLE *copy_series(const NETDATA_DOUBLE *series, size_t entries);
+void sort_series(NETDATA_DOUBLE *series, size_t entries);
 
 #endif //NETDATA_STATISTICAL_H
diff --git a/libnetdata/storage_number/storage_number.c b/libnetdata/storage_number/storage_number.c
index 6a8b68c11..7511f3a79 100644
--- a/libnetdata/storage_number/storage_number.c
+++ b/libnetdata/storage_number/storage_number.c
@@ -176,7 +176,8 @@ int print_netdata_double(char *str, NETDATA_DOUBLE value) {
 #ifdef STORAGE_WITH_MATH
     fractional = modfndd(value, &integral) * 10000000.0;
 #else
-    fractional = ((unsigned long long)(value * 10000000ULL) % 10000000ULL);
+    integral = (NETDATA_DOUBLE)((unsigned long long)(value * 10000000ULL) / 10000000ULL);
+    fractional = (NETDATA_DOUBLE)((unsigned long long)(value * 10000000ULL) % 10000000ULL);
 #endif
 
     unsigned long long integral_int = (unsigned long long)integral;
diff --git a/libnetdata/string/Makefile.am b/libnetdata/string/Makefile.am
new file mode 100644
index 000000000..161784b8f
--- /dev/null
+++ b/libnetdata/string/Makefile.am
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+AUTOMAKE_OPTIONS = subdir-objects
+MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
+
+dist_noinst_DATA = \
+    README.md \
+    $(NULL)
diff --git a/libnetdata/string/README.md b/libnetdata/string/README.md
new file mode 100644
index 000000000..e73ab2696
--- /dev/null
+++ b/libnetdata/string/README.md
@@ -0,0 +1,20 @@
+<!--
+custom_edit_url: https://github.com/netdata/netdata/edit/master/libnetdata/string/README.md
+-->
+
+# STRING
+
+STRING provides a way to allocate and free text strings, while de-duplicating them.
+
+It can be used similarly to libc string functions:
+
+ - `strdup()` and `strdupz()` become `string_strdupz()`.
+ - `strlen()` becomes `string_strlen()` (and it does not walkthrough the bytes of the string).
+ - `free()` and `freez()` become `string_freez()`.
+
+There is also a special `string_dup()` function that increases the reference counter of a STRING, avoiding the
+index lookup to find it.
+
+Once there is a `STRING *`, the actual `const char *` can be accessed with `string2str()`.
+
+All STRING should be constant. Changing the contents of a `const char *` that has been acquired by `string2str()` should never happen. 
\ No newline at end of file
diff --git a/libnetdata/string/string.c b/libnetdata/string/string.c
new file mode 100644
index 000000000..a3f74b4ef
--- /dev/null
+++ b/libnetdata/string/string.c
@@ -0,0 +1,595 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../libnetdata.h"
+#include <Judy.h>
+
+typedef int32_t REFCOUNT;
+
+// ----------------------------------------------------------------------------
+// STRING implementation - dedup all STRING
+
+struct netdata_string {
+    uint32_t length;    // the string length including the terminating '\0'
+
+    REFCOUNT refcount;  // how many times this string is used
+                        // We use a signed number to be able to detect duplicate frees of a string.
+                        // If at any point this goes below zero, we have a duplicate free.
+
+    const char str[];   // the string itself, is appended to this structure
+};
+
+static struct string_hashtable {
+    Pvoid_t JudyHSArray;        // the Judy array - hashtable
+    netdata_rwlock_t rwlock;    // the R/W lock to protect the Judy array
+
+    long int entries;           // the number of entries in the index
+    long int active_references; // the number of active references alive
+    long int memory;            // the memory used, without the JudyHS index
+
+    size_t inserts;             // the number of successful inserts to the index
+    size_t deletes;             // the number of successful deleted from the index
+    size_t searches;            // the number of successful searches in the index
+    size_t duplications;        // when a string is referenced
+    size_t releases;            // when a string is unreferenced
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    // internal statistics
+    size_t found_deleted_on_search;
+    size_t found_available_on_search;
+    size_t found_deleted_on_insert;
+    size_t found_available_on_insert;
+    size_t spins;
+#endif
+
+} string_base = {
+    .JudyHSArray = NULL,
+    .rwlock = NETDATA_RWLOCK_INITIALIZER,
+};
+
+#ifdef NETDATA_INTERNAL_CHECKS
+#define string_internal_stats_add(var, val) __atomic_add_fetch(&string_base.var, val, __ATOMIC_RELAXED)
+#else
+#define string_internal_stats_add(var, val) do {;} while(0)
+#endif
+
+#define string_stats_atomic_increment(var) __atomic_add_fetch(&string_base.var, 1, __ATOMIC_RELAXED)
+#define string_stats_atomic_decrement(var) __atomic_sub_fetch(&string_base.var, 1, __ATOMIC_RELAXED)
+
+void string_statistics(size_t *inserts, size_t *deletes, size_t *searches, size_t *entries, size_t *references, size_t *memory, size_t *duplications, size_t *releases) {
+    *inserts = string_base.inserts;
+    *deletes = string_base.deletes;
+    *searches = string_base.searches;
+    *entries = (size_t)string_base.entries;
+    *references = (size_t)string_base.active_references;
+    *memory = (size_t)string_base.memory;
+    *duplications = string_base.duplications;
+    *releases = string_base.releases;
+}
+
+#define string_entry_acquire(se) __atomic_add_fetch(&((se)->refcount), 1, __ATOMIC_SEQ_CST);
+#define string_entry_release(se) __atomic_sub_fetch(&((se)->refcount), 1, __ATOMIC_SEQ_CST);
+
+static inline bool string_entry_check_and_acquire(STRING *se) {
+    REFCOUNT expected, desired, count = 0;
+    do {
+        count++;
+
+        expected = __atomic_load_n(&se->refcount, __ATOMIC_SEQ_CST);
+
+        if(expected <= 0) {
+            // We cannot use this.
+            // The reference counter reached value zero,
+            // so another thread is deleting this.
+            string_internal_stats_add(spins, count - 1);
+            return false;
+        }
+
+        desired = expected + 1;
+    }
+    while(!__atomic_compare_exchange_n(&se->refcount, &expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST));
+
+    string_internal_stats_add(spins, count - 1);
+
+    // statistics
+    // string_base.active_references is altered at the in string_strdupz() and string_freez()
+    string_stats_atomic_increment(duplications);
+
+    return true;
+}
+
+STRING *string_dup(STRING *string) {
+    if(unlikely(!string)) return NULL;
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(unlikely(__atomic_load_n(&string->refcount, __ATOMIC_SEQ_CST) <= 0))
+        fatal("STRING: tried to %s() a string that is freed (it has %d references).", __FUNCTION__, string->refcount);
+#endif
+
+    string_entry_acquire(string);
+
+    // statistics
+    string_stats_atomic_increment(active_references);
+    string_stats_atomic_increment(duplications);
+
+    return string;
+}
+
+// Search the index and return an ACQUIRED string entry, or NULL
+static inline STRING *string_index_search(const char *str, size_t length) {
+    STRING *string;
+
+    // Find the string in the index
+    // With a read-lock so that multiple readers can use the index concurrently.
+
+    netdata_rwlock_rdlock(&string_base.rwlock);
+
+    Pvoid_t *Rc;
+    Rc = JudyHSGet(string_base.JudyHSArray, (void *)str, length);
+    if(likely(Rc)) {
+        // found in the hash table
+        string = *Rc;
+
+        if(string_entry_check_and_acquire(string)) {
+            // we can use this entry
+            string_internal_stats_add(found_available_on_search, 1);
+        }
+        else {
+            // this entry is about to be deleted by another thread
+            // do not touch it, let it go...
+            string = NULL;
+            string_internal_stats_add(found_deleted_on_search, 1);
+        }
+    }
+    else {
+        // not found in the hash table
+        string = NULL;
+    }
+
+    string_stats_atomic_increment(searches);
+    netdata_rwlock_unlock(&string_base.rwlock);
+
+    return string;
+}
+
+// Insert a string to the index and return an ACQUIRED string entry,
+// or NULL if the call needs to be retried (a deleted entry with the same key is still in the index)
+// The returned entry is ACQUIRED, and it can either be:
+//   1. a new item inserted, or
+//   2. an item found in the index that is not currently deleted
+static inline STRING *string_index_insert(const char *str, size_t length) {
+    STRING *string;
+
+    netdata_rwlock_wrlock(&string_base.rwlock);
+
+    STRING **ptr;
+    {
+        JError_t J_Error;
+        Pvoid_t *Rc = JudyHSIns(&string_base.JudyHSArray, (void *)str, length, &J_Error);
+        if (unlikely(Rc == PJERR)) {
+            fatal(
+                "STRING: Cannot insert entry with name '%s' to JudyHS, JU_ERRNO_* == %u, ID == %d",
+                str,
+                JU_ERRNO(&J_Error),
+                JU_ERRID(&J_Error));
+        }
+        ptr = (STRING **)Rc;
+    }
+
+    if (likely(*ptr == 0)) {
+        // a new item added to the index
+        size_t mem_size = sizeof(STRING) + length;
+        string = mallocz(mem_size);
+        strcpy((char *)string->str, str);
+        string->length = length;
+        string->refcount = 1;
+        *ptr = string;
+        string_base.inserts++;
+        string_base.entries++;
+        string_base.memory += (long)mem_size;
+    }
+    else {
+        // the item is already in the index
+        string = *ptr;
+
+        if(string_entry_check_and_acquire(string)) {
+            // we can use this entry
+            string_internal_stats_add(found_available_on_insert, 1);
+        }
+        else {
+            // this entry is about to be deleted by another thread
+            // do not touch it, let it go...
+            string = NULL;
+            string_internal_stats_add(found_deleted_on_insert, 1);
+        }
+
+        string_stats_atomic_increment(searches);
+    }
+
+    netdata_rwlock_unlock(&string_base.rwlock);
+    return string;
+}
+
+// delete an entry from the index
+static inline void string_index_delete(STRING *string) {
+    netdata_rwlock_wrlock(&string_base.rwlock);
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(unlikely(__atomic_load_n(&string->refcount, __ATOMIC_SEQ_CST) != 0))
+        fatal("STRING: tried to delete a string at %s() that is already freed (it has %d references).", __FUNCTION__, string->refcount);
+#endif
+
+    bool deleted = false;
+
+    if (likely(string_base.JudyHSArray)) {
+        JError_t J_Error;
+        int ret = JudyHSDel(&string_base.JudyHSArray, (void *)string->str, string->length, &J_Error);
+        if (unlikely(ret == JERR)) {
+            error(
+                "STRING: Cannot delete entry with name '%s' from JudyHS, JU_ERRNO_* == %u, ID == %d",
+                string->str,
+                JU_ERRNO(&J_Error),
+                JU_ERRID(&J_Error));
+        } else
+            deleted = true;
+    }
+
+    if (unlikely(!deleted))
+        error("STRING: tried to delete '%s' that is not in the index. Ignoring it.", string->str);
+    else {
+        size_t mem_size = sizeof(STRING) + string->length;
+        string_base.deletes++;
+        string_base.entries--;
+        string_base.memory -= (long)mem_size;
+        freez(string);
+    }
+
+    netdata_rwlock_unlock(&string_base.rwlock);
+}
+
+STRING *string_strdupz(const char *str) {
+    if(unlikely(!str || !*str)) return NULL;
+
+    size_t length = strlen(str) + 1;
+    STRING *string = string_index_search(str, length);
+
+    while(!string) {
+        // The search above did not find anything,
+        // We loop here, because during insert we may find an entry that is being deleted by another thread.
+        // So, we have to let it go and retry to insert it again.
+
+        string = string_index_insert(str, length);
+    }
+
+    // statistics
+    string_stats_atomic_increment(active_references);
+
+    return string;
+}
+
+void string_freez(STRING *string) {
+    if(unlikely(!string)) return;
+
+    REFCOUNT refcount = string_entry_release(string);
+
+#ifdef NETDATA_INTERNAL_CHECKS
+    if(unlikely(refcount < 0))
+        fatal("STRING: tried to %s() a string that is already freed (it has %d references).", __FUNCTION__, string->refcount);
+#endif
+
+    if(unlikely(refcount == 0))
+        string_index_delete(string);
+
+    // statistics
+    string_stats_atomic_decrement(active_references);
+    string_stats_atomic_increment(releases);
+}
+
+size_t string_strlen(STRING *string) {
+    if(unlikely(!string)) return 0;
+    return string->length - 1;
+}
+
+const char *string2str(STRING *string) {
+    if(unlikely(!string)) return "";
+    return string->str;
+}
+
+STRING *string_2way_merge(STRING *a, STRING *b) {
+    static STRING *X = NULL;
+
+    if(unlikely(!X)) {
+        X = string_strdupz("[x]");
+    }
+
+    if(unlikely(a == b)) return string_dup(a);
+    if(unlikely(a == X)) return string_dup(a);
+    if(unlikely(b == X)) return string_dup(b);
+    if(unlikely(!a)) return string_dup(X);
+    if(unlikely(!b)) return string_dup(X);
+
+    size_t alen = string_strlen(a);
+    size_t blen = string_strlen(b);
+    size_t length = alen + blen + string_strlen(X) + 1;
+    char buf1[length + 1], buf2[length + 1], *dst1;
+    const char *s1, *s2;
+
+    s1 = string2str(a);
+    s2 = string2str(b);
+    dst1 = buf1;
+    for( ; *s1 && *s2 && *s1 == *s2 ;s1++, s2++)
+        *dst1++ = *s1;
+
+    *dst1 = '\0';
+
+    if(*s1 != '\0' || *s2 != '\0') {
+        *dst1++ = '[';
+        *dst1++ = 'x';
+        *dst1++ = ']';
+
+        s1 = &(string2str(a))[alen - 1];
+        s2 = &(string2str(b))[blen - 1];
+        char *dst2 = &buf2[length];
+        *dst2 = '\0';
+        for (; *s1 && *s2 && *s1 == *s2; s1--, s2--)
+            *(--dst2) = *s1;
+
+        strcpy(dst1, dst2);
+    }
+
+    return string_strdupz(buf1);
+}
+
+// ----------------------------------------------------------------------------
+// STRING unit test
+
+struct thread_unittest {
+    int join;
+    int dups;
+};
+
+static void *string_thread(void *arg) {
+    struct thread_unittest *tu = arg;
+
+    for(; 1 ;) {
+        if(__atomic_load_n(&tu->join, __ATOMIC_RELAXED))
+            break;
+
+        STRING *s = string_strdupz("string thread checking 1234567890");
+
+        for(int i = 0; i < tu->dups ; i++)
+            string_dup(s);
+
+        for(int i = 0; i < tu->dups ; i++)
+            string_freez(s);
+
+        string_freez(s);
+    }
+
+    return arg;
+}
+
+static char **string_unittest_generate_names(size_t entries) {
+    char **names = mallocz(sizeof(char *) * entries);
+    for(size_t i = 0; i < entries ;i++) {
+        char buf[25 + 1] = "";
+        snprintfz(buf, 25, "name.%zu.0123456789.%zu \t !@#$%%^&*(),./[]{}\\|~`", i, entries / 2 + i);
+        names[i] = strdupz(buf);
+    }
+    return names;
+}
+
+static void string_unittest_free_char_pp(char **pp, size_t entries) {
+    for(size_t i = 0; i < entries ;i++)
+        freez(pp[i]);
+
+    freez(pp);
+}
+
+int string_unittest(size_t entries) {
+    size_t errors = 0;
+
+    fprintf(stderr, "Generating %zu names and values...\n", entries);
+    char **names = string_unittest_generate_names(entries);
+
+    // check string
+    {
+        long int string_entries_starting = string_base.entries;
+
+        fprintf(stderr, "\nChecking strings...\n");
+
+        STRING *s1 = string_strdupz("hello unittest");
+        STRING *s2 = string_strdupz("hello unittest");
+        if(s1 != s2) {
+            errors++;
+            fprintf(stderr, "ERROR: duplicating strings are not deduplicated\n");
+        }
+        else
+            fprintf(stderr, "OK: duplicating string are deduplicated\n");
+
+        STRING *s3 = string_dup(s1);
+        if(s3 != s1) {
+            errors++;
+            fprintf(stderr, "ERROR: cloning strings are not deduplicated\n");
+        }
+        else
+            fprintf(stderr, "OK: cloning string are deduplicated\n");
+
+        if(s1->refcount != 3) {
+            errors++;
+            fprintf(stderr, "ERROR: string refcount is not 3\n");
+        }
+        else
+            fprintf(stderr, "OK: string refcount is 3\n");
+
+        STRING *s4 = string_strdupz("world unittest");
+        if(s4 == s1) {
+            errors++;
+            fprintf(stderr, "ERROR: string is sharing pointers on different strings\n");
+        }
+        else
+            fprintf(stderr, "OK: string is properly handling different strings\n");
+
+        usec_t start_ut, end_ut;
+        STRING **strings = mallocz(entries * sizeof(STRING *));
+
+        start_ut = now_realtime_usec();
+        for(size_t i = 0; i < entries ;i++) {
+            strings[i] = string_strdupz(names[i]);
+        }
+        end_ut = now_realtime_usec();
+        fprintf(stderr, "Created %zu strings in %llu usecs\n", entries, end_ut - start_ut);
+
+        start_ut = now_realtime_usec();
+        for(size_t i = 0; i < entries ;i++) {
+            strings[i] = string_dup(strings[i]);
+        }
+        end_ut = now_realtime_usec();
+        fprintf(stderr, "Cloned %zu strings in %llu usecs\n", entries, end_ut - start_ut);
+
+        start_ut = now_realtime_usec();
+        for(size_t i = 0; i < entries ;i++) {
+            strings[i] = string_strdupz(string2str(strings[i]));
+        }
+        end_ut = now_realtime_usec();
+        fprintf(stderr, "Found %zu existing strings in %llu usecs\n", entries, end_ut - start_ut);
+
+        start_ut = now_realtime_usec();
+        for(size_t i = 0; i < entries ;i++) {
+            string_freez(strings[i]);
+        }
+        end_ut = now_realtime_usec();
+        fprintf(stderr, "Released %zu referenced strings in %llu usecs\n", entries, end_ut - start_ut);
+
+        start_ut = now_realtime_usec();
+        for(size_t i = 0; i < entries ;i++) {
+            string_freez(strings[i]);
+        }
+        end_ut = now_realtime_usec();
+        fprintf(stderr, "Released (again) %zu referenced strings in %llu usecs\n", entries, end_ut - start_ut);
+
+        start_ut = now_realtime_usec();
+        for(size_t i = 0; i < entries ;i++) {
+            string_freez(strings[i]);
+        }
+        end_ut = now_realtime_usec();
+        fprintf(stderr, "Freed %zu strings in %llu usecs\n", entries, end_ut - start_ut);
+
+        freez(strings);
+
+        if(string_base.entries != string_entries_starting + 2) {
+            errors++;
+            fprintf(stderr, "ERROR: strings dictionary should have %ld items but it has %ld\n", string_entries_starting + 2, string_base.entries);
+        }
+        else
+            fprintf(stderr, "OK: strings dictionary has 2 items\n");
+    }
+
+    // check 2-way merge
+    {
+        struct testcase {
+            char *src1; char *src2; char *expected;
+        } tests[] = {
+            { "", "", ""},
+            { "a", "", "[x]"},
+            { "", "a", "[x]"},
+            { "a", "a", "a"},
+            { "abcd", "abcd", "abcd"},
+            { "foo_cs", "bar_cs", "[x]_cs"},
+            { "cp_UNIQUE_INFIX_cs", "cp_unique_infix_cs", "cp_[x]_cs"},
+            { "cp_UNIQUE_INFIX_ci_unique_infix_cs", "cp_unique_infix_ci_UNIQUE_INFIX_cs", "cp_[x]_cs"},
+            { "foo[1234]", "foo[4321]", "foo[[x]]"},
+            { NULL, NULL, NULL },
+        };
+
+        for (struct testcase *tc = &tests[0]; tc->expected != NULL; tc++) {
+            STRING *src1 = string_strdupz(tc->src1);
+            STRING *src2 = string_strdupz(tc->src2);
+            STRING *expected = string_strdupz(tc->expected);
+
+            STRING *result = string_2way_merge(src1, src2);
+            if (string_cmp(result, expected) != 0) {
+                fprintf(stderr, "string_2way_merge(\"%s\", \"%s\") -> \"%s\" (expected=\"%s\")\n",
+                        string2str(src1),
+                        string2str(src2),
+                        string2str(result),
+                        string2str(expected));
+                errors++;
+            }
+
+            string_freez(src1);
+            string_freez(src2);
+            string_freez(expected);
+            string_freez(result);
+        }
+    }
+
+    // threads testing of string
+    {
+        struct thread_unittest tu = {
+            .dups = 1,
+            .join = 0,
+        };
+
+#ifdef NETDATA_INTERNAL_CHECKS
+        size_t ofound_deleted_on_search = string_base.found_deleted_on_search,
+               ofound_available_on_search = string_base.found_available_on_search,
+               ofound_deleted_on_insert = string_base.found_deleted_on_insert,
+               ofound_available_on_insert = string_base.found_available_on_insert,
+               ospins = string_base.spins;
+#endif
+
+        size_t oinserts, odeletes, osearches, oentries, oreferences, omemory, oduplications, oreleases;
+        string_statistics(&oinserts, &odeletes, &osearches, &oentries, &oreferences, &omemory, &oduplications, &oreleases);
+
+        time_t seconds_to_run = 5;
+        int threads_to_create = 2;
+        fprintf(
+            stderr,
+            "Checking string concurrency with %d threads for %lld seconds...\n",
+            threads_to_create,
+            (long long)seconds_to_run);
+        // check string concurrency
+        netdata_thread_t threads[threads_to_create];
+        tu.join = 0;
+        for (int i = 0; i < threads_to_create; i++) {
+            char buf[100 + 1];
+            snprintf(buf, 100, "string%d", i);
+            netdata_thread_create(
+                &threads[i], buf, NETDATA_THREAD_OPTION_DONT_LOG | NETDATA_THREAD_OPTION_JOINABLE, string_thread, &tu);
+        }
+        sleep_usec(seconds_to_run * USEC_PER_SEC);
+
+        __atomic_store_n(&tu.join, 1, __ATOMIC_RELAXED);
+        for (int i = 0; i < threads_to_create; i++) {
+            void *retval;
+            netdata_thread_join(threads[i], &retval);
+        }
+
+        size_t inserts, deletes, searches, sentries, references, memory, duplications, releases;
+        string_statistics(&inserts, &deletes, &searches, &sentries, &references, &memory, &duplications, &releases);
+
+        fprintf(stderr, "inserts %zu, deletes %zu, searches %zu, entries %zu, references %zu, memory %zu, duplications %zu, releases %zu\n",
+                inserts - oinserts, deletes - odeletes, searches - osearches, sentries - oentries, references - oreferences, memory - omemory, duplications - oduplications, releases - oreleases);
+
+#ifdef NETDATA_INTERNAL_CHECKS
+        size_t found_deleted_on_search = string_base.found_deleted_on_search,
+               found_available_on_search = string_base.found_available_on_search,
+               found_deleted_on_insert = string_base.found_deleted_on_insert,
+               found_available_on_insert = string_base.found_available_on_insert,
+               spins = string_base.spins;
+
+        fprintf(stderr, "on insert: %zu ok + %zu deleted\non search: %zu ok + %zu deleted\nspins: %zu\n",
+                found_available_on_insert - ofound_available_on_insert,
+                found_deleted_on_insert - ofound_deleted_on_insert,
+                found_available_on_search - ofound_available_on_search,
+                found_deleted_on_search - ofound_deleted_on_search,
+                spins - ospins
+        );
+#endif
+    }
+
+    string_unittest_free_char_pp(names, entries);
+
+    fprintf(stderr, "\n%zu errors found\n", errors);
+    return  errors ? 1 : 0;
+}
diff --git a/libnetdata/string/string.h b/libnetdata/string/string.h
new file mode 100644
index 000000000..cec44ebd9
--- /dev/null
+++ b/libnetdata/string/string.h
@@ -0,0 +1,30 @@
+
+#ifndef NETDATA_STRING_H
+#define NETDATA_STRING_H 1
+
+#include "../libnetdata.h"
+
+// ----------------------------------------------------------------------------
+// STRING implementation
+
+typedef struct netdata_string STRING;
+STRING *string_strdupz(const char *str);
+STRING *string_dup(STRING *string);
+void string_freez(STRING *string);
+size_t string_strlen(STRING *string);
+const char *string2str(STRING *string) NEVERNULL;
+
+// keep common prefix/suffix and replace everything else with [x]
+STRING *string_2way_merge(STRING *a, STRING *b);
+
+static inline int string_cmp(STRING *s1, STRING *s2) {
+    // STRINGs are deduplicated, so the same strings have the same pointer
+    // when they differ, we do the typical strcmp() comparison
+    return (s1 == s2)?0:strcmp(string2str(s1), string2str(s2));
+}
+
+void string_statistics(size_t *inserts, size_t *deletes, size_t *searches, size_t *entries, size_t *references, size_t *memory, size_t *duplications, size_t *releases);
+
+int string_unittest(size_t entries);
+
+#endif
diff --git a/libnetdata/threads/threads.c b/libnetdata/threads/threads.c
index 12007afff..5c3d2675c 100644
--- a/libnetdata/threads/threads.c
+++ b/libnetdata/threads/threads.c
@@ -29,26 +29,35 @@ const char *netdata_thread_tag(void) {
 // ----------------------------------------------------------------------------
 // compatibility library functions
 
+static __thread pid_t gettid_cached_tid = 0;
 pid_t gettid(void) {
+    pid_t tid = 0;
+
+    if(likely(gettid_cached_tid > 0))
+        return gettid_cached_tid;
+
 #ifdef __FreeBSD__
 
-    return (pid_t)pthread_getthreadid_np();
+    tid = (pid_t)pthread_getthreadid_np();
 
 #elif defined(__APPLE__)
 
     #if (defined __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1060)
         uint64_t curthreadid;
         pthread_threadid_np(NULL, &curthreadid);
-        return (pid_t)curthreadid;
+        tid = (pid_t)curthreadid;
     #else /* __MAC_OS_X_VERSION_MIN_REQUIRED */
-        return (pid_t)pthread_self;
+        tid = (pid_t)pthread_self;
     #endif /* __MAC_OS_X_VERSION_MIN_REQUIRED */
 
 #else /* __APPLE__*/
 
-    return (pid_t)syscall(SYS_gettid);
+    tid = (pid_t)syscall(SYS_gettid);
 
 #endif /* __FreeBSD__, __APPLE__*/
+
+    gettid_cached_tid = tid;
+    return tid;
 }
 
 // ----------------------------------------------------------------------------
@@ -97,6 +106,10 @@ void netdata_threads_init_after_fork(size_t stacksize) {
 // ----------------------------------------------------------------------------
 // netdata_thread_create
 
+extern void rrdset_thread_rda_free(void);
+extern void sender_thread_buffer_free(void);
+extern void query_target_free(void);
+
 static void thread_cleanup(void *ptr) {
     if(netdata_thread != ptr) {
         NETDATA_THREAD *info = (NETDATA_THREAD *)ptr;
@@ -106,6 +119,11 @@ static void thread_cleanup(void *ptr) {
     if(!(netdata_thread->options & NETDATA_THREAD_OPTION_DONT_LOG_CLEANUP))
         info("thread with task id %d finished", gettid());
 
+    sender_thread_buffer_free();
+    rrdset_thread_rda_free();
+    query_target_free();
+    thread_cache_destroy();
+
     freez((void *)netdata_thread->tag);
     netdata_thread->tag = NULL;
 
@@ -213,11 +231,18 @@ int netdata_thread_create(netdata_thread_t *thread, const char *tag, NETDATA_THR
 
 // ----------------------------------------------------------------------------
 // netdata_thread_cancel
-
+#ifdef NETDATA_INTERNAL_CHECKS
+int netdata_thread_cancel_with_trace(netdata_thread_t thread, int line, const char *file, const char *function) {
+#else
 int netdata_thread_cancel(netdata_thread_t thread) {
+#endif
     int ret = pthread_cancel(thread);
     if(ret != 0)
+#ifdef NETDATA_INTERNAL_CHECKS
+        error("cannot cancel thread. pthread_cancel() failed with code %d at %d@%s, function %s()", ret, line, file, function);
+#else
         error("cannot cancel thread. pthread_cancel() failed with code %d.", ret);
+#endif
 
     return ret;
 }
diff --git a/libnetdata/threads/threads.h b/libnetdata/threads/threads.h
index e7d79d328..ccc18aff0 100644
--- a/libnetdata/threads/threads.h
+++ b/libnetdata/threads/threads.h
@@ -5,7 +5,7 @@
 
 #include "../libnetdata.h"
 
-extern pid_t gettid(void);
+pid_t gettid(void);
 
 typedef enum {
     NETDATA_THREAD_OPTION_DEFAULT          = 0 << 0,
@@ -21,20 +21,27 @@ typedef enum {
 typedef pthread_t netdata_thread_t;
 
 #define NETDATA_THREAD_TAG_MAX 100
-extern const char *netdata_thread_tag(void);
-extern int netdata_thread_tag_exists(void);
+const char *netdata_thread_tag(void);
+int netdata_thread_tag_exists(void);
 
-extern size_t netdata_threads_init(void);
-extern void netdata_threads_init_after_fork(size_t stacksize);
+size_t netdata_threads_init(void);
+void netdata_threads_init_after_fork(size_t stacksize);
 
-extern int netdata_thread_create(netdata_thread_t *thread, const char *tag, NETDATA_THREAD_OPTIONS options, void *(*start_routine) (void *), void *arg);
-extern int netdata_thread_cancel(netdata_thread_t thread);
-extern int netdata_thread_join(netdata_thread_t thread, void **retval);
-extern int netdata_thread_detach(pthread_t thread);
+int netdata_thread_create(netdata_thread_t *thread, const char *tag, NETDATA_THREAD_OPTIONS options, void *(*start_routine) (void *), void *arg);
+
+#ifdef NETDATA_INTERNAL_CHECKS
+#define netdata_thread_cancel(thread) netdata_thread_cancel_with_trace(thread, __LINE__, __FILE__, __FUNCTION__)
+int netdata_thread_cancel_with_trace(netdata_thread_t thread, int line, const char *file, const char *function);
+#else
+int netdata_thread_cancel(netdata_thread_t thread);
+#endif
+
+int netdata_thread_join(netdata_thread_t thread, void **retval);
+int netdata_thread_detach(pthread_t thread);
 
 #define NETDATA_THREAD_NAME_MAX 15
-extern void uv_thread_set_name_np(uv_thread_t ut, const char* name);
-extern void os_thread_get_current_name_np(char threadname[NETDATA_THREAD_NAME_MAX + 1]);
+void uv_thread_set_name_np(uv_thread_t ut, const char* name);
+void os_thread_get_current_name_np(char threadname[NETDATA_THREAD_NAME_MAX + 1]);
 
 #define netdata_thread_self pthread_self
 #define netdata_thread_testcancel pthread_testcancel
diff --git a/libnetdata/url/url.h b/libnetdata/url/url.h
index 10f3fe176..da0f69ac1 100644
--- a/libnetdata/url/url.h
+++ b/libnetdata/url/url.h
@@ -10,26 +10,26 @@
 // code from: http://www.geekhideout.com/urlcode.shtml
 
 /* Converts a hex character to its integer value */
-extern char from_hex(char ch);
+char from_hex(char ch);
 
 /* Converts an integer value to its hex character*/
-extern char to_hex(char code);
+char to_hex(char code);
 
 /* Returns a url-encoded version of str */
 /* IMPORTANT: be sure to free() the returned string after use */
-extern char *url_encode(char *str);
+char *url_encode(char *str);
 
 /* Returns a url-decoded version of str */
 /* IMPORTANT: be sure to free() the returned string after use */
-extern char *url_decode(char *str);
+char *url_decode(char *str);
 
-extern char *url_decode_r(char *to, char *url, size_t size);
+char *url_decode_r(char *to, char *url, size_t size);
 
 #define WEB_FIELDS_MAX 400
-extern int url_map_query_string(char **out, char *url);
-extern int url_parse_query_string(char *output, size_t max, char **map, int total);
+int url_map_query_string(char **out, char *url);
+int url_parse_query_string(char *output, size_t max, char **map, int total);
 
-extern int url_is_request_complete(char *begin,char *end,size_t length);
-extern char *url_find_protocol(char *s);
+int url_is_request_complete(char *begin,char *end,size_t length);
+char *url_find_protocol(char *s);
 
 #endif /* NETDATA_URL_H */
diff --git a/libnetdata/worker_utilization/worker_utilization.c b/libnetdata/worker_utilization/worker_utilization.c
index bd3ad60e0..14b8926e0 100644
--- a/libnetdata/worker_utilization/worker_utilization.c
+++ b/libnetdata/worker_utilization/worker_utilization.c
@@ -4,22 +4,26 @@
 #define WORKER_BUSY 'B'
 
 struct worker_job_type {
-    char name[WORKER_UTILIZATION_MAX_JOB_NAME_LENGTH + 1];
+    STRING *name;
+    STRING *units;
 
     // statistics controlled variables
     size_t statistics_last_jobs_started;
     usec_t statistics_last_busy_time;
+    NETDATA_DOUBLE statistics_last_custom_value;
 
     // worker controlled variables
     volatile size_t worker_jobs_started;
     volatile usec_t worker_busy_time;
+
+    WORKER_METRIC_TYPE type;
+    NETDATA_DOUBLE custom_value;
 };
 
 struct worker {
     pid_t pid;
     const char *tag;
     const char *workname;
-    uint32_t workname_hash;
 
     // statistics controlled variables
     volatile usec_t statistics_last_checkpoint;
@@ -27,6 +31,7 @@ struct worker {
     usec_t statistics_last_busy_time;
 
     // the worker controlled variables
+    size_t worker_max_job_id;
     volatile size_t job_id;
     volatile size_t jobs_started;
     volatile usec_t busy_time;
@@ -36,11 +41,12 @@ struct worker {
     struct worker_job_type per_job_type[WORKER_UTILIZATION_MAX_JOB_TYPES];
 
     struct worker *next;
+    struct worker *prev;
 };
 
-static netdata_mutex_t base_lock = NETDATA_MUTEX_INITIALIZER;
-static struct worker *base = NULL;
+static netdata_mutex_t workers_base_lock = NETDATA_MUTEX_INITIALIZER;
 static __thread struct worker *worker = NULL;
+static Pvoid_t workers_per_workname_JudyHS_array = NULL;
 
 void worker_register(const char *workname) {
     if(unlikely(worker)) return;
@@ -49,47 +55,72 @@ void worker_register(const char *workname) {
     worker->pid = gettid();
     worker->tag = strdupz(netdata_thread_tag());
     worker->workname = strdupz(workname);
-    worker->workname_hash = simple_hash(worker->workname);
 
-    usec_t now = now_realtime_usec();
+    usec_t now = now_monotonic_usec();
     worker->statistics_last_checkpoint = now;
     worker->last_action_timestamp = now;
     worker->last_action = WORKER_IDLE;
 
-    netdata_mutex_lock(&base_lock);
-    worker->next = base;
-    base = worker;
-    netdata_mutex_unlock(&base_lock);
+    size_t workname_size = strlen(workname) + 1;
+    netdata_mutex_lock(&workers_base_lock);
+
+    Pvoid_t *PValue = JudyHSGet(workers_per_workname_JudyHS_array, (void *)workname, workname_size);
+    if(!PValue)
+        PValue = JudyHSIns(&workers_per_workname_JudyHS_array, (void *)workname, workname_size, PJE0);
+
+    struct worker *base = *PValue;
+    DOUBLE_LINKED_LIST_APPEND_UNSAFE(base, worker, prev, next);
+    *PValue = base;
+
+    netdata_mutex_unlock(&workers_base_lock);
 }
 
-void worker_register_job_name(size_t job_id, const char *name) {
+void worker_register_job_custom_metric(size_t job_id, const char *name, const char *units, WORKER_METRIC_TYPE type) {
     if(unlikely(!worker)) return;
 
     if(unlikely(job_id >= WORKER_UTILIZATION_MAX_JOB_TYPES)) {
         error("WORKER_UTILIZATION: job_id %zu is too big. Max is %zu", job_id, (size_t)(WORKER_UTILIZATION_MAX_JOB_TYPES - 1));
         return;
     }
-    if (*worker->per_job_type[job_id].name) {
-        error("WORKER_UTILIZATION: duplicate job registration: worker '%s' job id %zu is '%s', ignoring '%s'", worker->workname, job_id, worker->per_job_type[job_id].name, name);
+
+    if(job_id > worker->worker_max_job_id)
+        worker->worker_max_job_id = job_id;
+
+    if(worker->per_job_type[job_id].name) {
+        if(strcmp(string2str(worker->per_job_type[job_id].name), name) != 0 || worker->per_job_type[job_id].type != type || strcmp(string2str(worker->per_job_type[job_id].units), units) != 0)
+            error("WORKER_UTILIZATION: duplicate job registration: worker '%s' job id %zu is '%s', ignoring the later '%s'", worker->workname, job_id, string2str(worker->per_job_type[job_id].name), name);
         return;
     }
 
-    strncpy(worker->per_job_type[job_id].name, name, WORKER_UTILIZATION_MAX_JOB_NAME_LENGTH);
+    worker->per_job_type[job_id].name = string_strdupz(name);
+    worker->per_job_type[job_id].units = string_strdupz(units);
+    worker->per_job_type[job_id].type = type;
+}
+
+void worker_register_job_name(size_t job_id, const char *name) {
+    worker_register_job_custom_metric(job_id, name, "", WORKER_METRIC_IDLE_BUSY);
 }
 
 void worker_unregister(void) {
     if(unlikely(!worker)) return;
 
-    netdata_mutex_lock(&base_lock);
-    if(base == worker)
-        base = worker->next;
-    else {
-        struct worker *p;
-        for(p = base; p && p->next && p->next != worker ;p = p->next);
-        if(p && p->next == worker)
-            p->next = worker->next;
+    size_t workname_size = strlen(worker->workname) + 1;
+    netdata_mutex_lock(&workers_base_lock);
+    Pvoid_t *PValue = JudyHSGet(workers_per_workname_JudyHS_array, (void *)worker->workname, workname_size);
+    if(PValue) {
+        struct worker *base = *PValue;
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(base, worker, prev, next);
+        *PValue = base;
+
+        if(!base)
+            JudyHSDel(&workers_per_workname_JudyHS_array, (void *)worker->workname, workname_size, PJE0);
+    }
+    netdata_mutex_unlock(&workers_base_lock);
+
+    for(int i  = 0; i < WORKER_UTILIZATION_MAX_JOB_TYPES ;i++) {
+        string_freez(worker->per_job_type[i].name);
+        string_freez(worker->per_job_type[i].units);
     }
-    netdata_mutex_unlock(&base_lock);
 
     freez((void *)worker->tag);
     freez((void *)worker->workname);
@@ -112,18 +143,16 @@ static inline void worker_is_idle_with_time(usec_t now) {
 }
 
 void worker_is_idle(void) {
-    if(unlikely(!worker)) return;
-    if(unlikely(worker->last_action != WORKER_BUSY)) return;
+    if(unlikely(!worker || worker->last_action != WORKER_BUSY)) return;
 
-    worker_is_idle_with_time(now_realtime_usec());
+    worker_is_idle_with_time(now_monotonic_usec());
 }
 
 void worker_is_busy(size_t job_id) {
-    if(unlikely(!worker)) return;
-    if(unlikely(job_id >= WORKER_UTILIZATION_MAX_JOB_TYPES))
-        job_id = 0;
+    if(unlikely(!worker || job_id >= WORKER_UTILIZATION_MAX_JOB_TYPES))
+        return;
 
-    usec_t now = now_realtime_usec();
+    usec_t now = now_monotonic_usec();
 
     if(worker->last_action == WORKER_BUSY)
         worker_is_idle_with_time(now);
@@ -138,35 +167,112 @@ void worker_is_busy(size_t job_id) {
     worker->last_action = WORKER_BUSY;
 }
 
+void worker_set_metric(size_t job_id, NETDATA_DOUBLE value) {
+    if(unlikely(!worker)) return;
+    if(unlikely(job_id >= WORKER_UTILIZATION_MAX_JOB_TYPES))
+        return;
+
+    switch(worker->per_job_type[job_id].type) {
+        case WORKER_METRIC_INCREMENT:
+            worker->per_job_type[job_id].custom_value += value;
+            break;
+
+        case WORKER_METRIC_INCREMENTAL_TOTAL:
+        case WORKER_METRIC_ABSOLUTE:
+        default:
+            worker->per_job_type[job_id].custom_value = value;
+            break;
+    }
+}
 
 // statistics interface
 
-void workers_foreach(const char *workname, void (*callback)(void *data, pid_t pid, const char *thread_tag, size_t utilization_usec, size_t duration_usec, size_t jobs_started, size_t is_running, const char **job_types_names, size_t *job_types_jobs_started, usec_t *job_types_busy_time), void *data) {
-    netdata_mutex_lock(&base_lock);
-    uint32_t hash = simple_hash(workname);
+void workers_foreach(const char *workname, void (*callback)(
+                                               void *data
+                                               , pid_t pid
+                                               , const char *thread_tag
+                                               , size_t max_job_id
+                                               , size_t utilization_usec
+                                               , size_t duration_usec
+                                               , size_t jobs_started, size_t is_running
+                                               , STRING **job_types_names
+                                               , STRING **job_types_units
+                                               , WORKER_METRIC_TYPE *job_metric_types
+                                               , size_t *job_types_jobs_started
+                                               , usec_t *job_types_busy_time
+                                               , NETDATA_DOUBLE *job_custom_values
+                                               )
+                                               , void *data) {
+    netdata_mutex_lock(&workers_base_lock);
     usec_t busy_time, delta;
     size_t i, jobs_started, jobs_running;
 
-    struct worker *p;
-    for(p = base; p ; p = p->next) {
-        if(hash != p->workname_hash || strcmp(workname, p->workname)) continue;
+    size_t workname_size = strlen(workname) + 1;
+    struct worker *base = NULL;
+    Pvoid_t *PValue = JudyHSGet(workers_per_workname_JudyHS_array, (void *)workname, workname_size);
+    if(PValue)
+        base = *PValue;
 
-        usec_t now = now_realtime_usec();
+    struct worker *p;
+    DOUBLE_LINKED_LIST_FOREACH_FORWARD(base, p, prev, next) {
+        usec_t now = now_monotonic_usec();
 
         // find per job type statistics
-        const char *per_job_type_name[WORKER_UTILIZATION_MAX_JOB_TYPES];
+        STRING *per_job_type_name[WORKER_UTILIZATION_MAX_JOB_TYPES];
+        STRING *per_job_type_units[WORKER_UTILIZATION_MAX_JOB_TYPES];
+        WORKER_METRIC_TYPE per_job_metric_type[WORKER_UTILIZATION_MAX_JOB_TYPES];
         size_t per_job_type_jobs_started[WORKER_UTILIZATION_MAX_JOB_TYPES];
         usec_t per_job_type_busy_time[WORKER_UTILIZATION_MAX_JOB_TYPES];
-        for(i  = 0; i < WORKER_UTILIZATION_MAX_JOB_TYPES ;i++) {
-            per_job_type_name[i] = p->per_job_type[i].name;
-
-            size_t tmp_jobs_started = p->per_job_type[i].worker_jobs_started;
-            per_job_type_jobs_started[i] = tmp_jobs_started - p->per_job_type[i].statistics_last_jobs_started;
-            p->per_job_type[i].statistics_last_jobs_started = tmp_jobs_started;
+        NETDATA_DOUBLE per_job_custom_values[WORKER_UTILIZATION_MAX_JOB_TYPES];
 
-            usec_t tmp_busy_time = p->per_job_type[i].worker_busy_time;
-            per_job_type_busy_time[i] = tmp_busy_time - p->per_job_type[i].statistics_last_busy_time;
-            p->per_job_type[i].statistics_last_busy_time = tmp_busy_time;
+        size_t max_job_id = p->worker_max_job_id;
+        for(i  = 0; i <= max_job_id ;i++) {
+            per_job_type_name[i] = p->per_job_type[i].name;
+            per_job_type_units[i] = p->per_job_type[i].units;
+            per_job_metric_type[i] = p->per_job_type[i].type;
+
+            switch(p->per_job_type[i].type) {
+                default:
+                case WORKER_METRIC_EMPTY: {
+                    per_job_type_jobs_started[i] = 0;
+                    per_job_type_busy_time[i] = 0;
+                    per_job_custom_values[i] = NAN;
+                    break;
+                }
+
+                case WORKER_METRIC_IDLE_BUSY: {
+                    size_t tmp_jobs_started = p->per_job_type[i].worker_jobs_started;
+                    per_job_type_jobs_started[i] = tmp_jobs_started - p->per_job_type[i].statistics_last_jobs_started;
+                    p->per_job_type[i].statistics_last_jobs_started = tmp_jobs_started;
+
+                    usec_t tmp_busy_time = p->per_job_type[i].worker_busy_time;
+                    per_job_type_busy_time[i] = tmp_busy_time - p->per_job_type[i].statistics_last_busy_time;
+                    p->per_job_type[i].statistics_last_busy_time = tmp_busy_time;
+
+                    per_job_custom_values[i] = NAN;
+                    break;
+                }
+
+                case WORKER_METRIC_ABSOLUTE: {
+                    per_job_type_jobs_started[i] = 0;
+                    per_job_type_busy_time[i] = 0;
+
+                    per_job_custom_values[i] = p->per_job_type[i].custom_value;
+                    break;
+                }
+
+                case WORKER_METRIC_INCREMENTAL_TOTAL:
+                case WORKER_METRIC_INCREMENT: {
+                    per_job_type_jobs_started[i] = 0;
+                    per_job_type_busy_time[i] = 0;
+
+                    NETDATA_DOUBLE tmp_custom_value = p->per_job_type[i].custom_value;
+                    per_job_custom_values[i] = tmp_custom_value - p->per_job_type[i].statistics_last_custom_value;
+                    p->per_job_type[i].statistics_last_custom_value = tmp_custom_value;
+
+                    break;
+                }
+            }
         }
 
         // get a copy of the worker variables
@@ -203,8 +309,22 @@ void workers_foreach(const char *workname, void (*callback)(void *data, pid_t pi
             jobs_running = 1;
         }
 
-        callback(data, p->pid, p->tag, busy_time, delta, jobs_started, jobs_running, per_job_type_name, per_job_type_jobs_started, per_job_type_busy_time);
+        callback(data
+                 , p->pid
+                 , p->tag
+                 , max_job_id
+                 , busy_time
+                 , delta
+                 , jobs_started
+                 , jobs_running
+                 , per_job_type_name
+                 , per_job_type_units
+                 , per_job_metric_type
+                 , per_job_type_jobs_started
+                 , per_job_type_busy_time
+                 , per_job_custom_values
+                 );
     }
 
-    netdata_mutex_unlock(&base_lock);
+    netdata_mutex_unlock(&workers_base_lock);
 }
diff --git a/libnetdata/worker_utilization/worker_utilization.h b/libnetdata/worker_utilization/worker_utilization.h
index 8f16fe054..04d24f1f7 100644
--- a/libnetdata/worker_utilization/worker_utilization.h
+++ b/libnetdata/worker_utilization/worker_utilization.h
@@ -6,17 +6,42 @@
 // workers interfaces
 
 #define WORKER_UTILIZATION_MAX_JOB_TYPES 50
-#define WORKER_UTILIZATION_MAX_JOB_NAME_LENGTH 25
 
-extern void worker_register(const char *workname);
-extern void worker_register_job_name(size_t job_id, const char *name);
-extern void worker_unregister(void);
+typedef enum {
+    WORKER_METRIC_EMPTY = 0,
+    WORKER_METRIC_IDLE_BUSY = 1,
+    WORKER_METRIC_ABSOLUTE = 2,
+    WORKER_METRIC_INCREMENT = 3,
+    WORKER_METRIC_INCREMENTAL_TOTAL = 4,
+} WORKER_METRIC_TYPE;
 
-extern void worker_is_idle(void);
-extern void worker_is_busy(size_t job_id);
+void worker_register(const char *workname);
+void worker_register_job_name(size_t job_id, const char *name);
+void worker_register_job_custom_metric(size_t job_id, const char *name, const char *units, WORKER_METRIC_TYPE type);
+void worker_unregister(void);
+
+void worker_is_idle(void);
+void worker_is_busy(size_t job_id);
+void worker_set_metric(size_t job_id, NETDATA_DOUBLE value);
 
 // statistics interface
 
-extern void workers_foreach(const char *workname, void (*callback)(void *data, pid_t pid, const char *thread_tag, size_t utilization_usec, size_t duration_usec, size_t jobs_started, size_t is_running, const char **job_types_names, size_t *job_types_jobs_started, usec_t *job_types_busy_time), void *data);
+void workers_foreach(const char *workname, void (*callback)(
+                                                      void *data
+                                                      , pid_t pid
+                                                      , const char *thread_tag
+                                                      , size_t max_job_id
+                                                      , size_t utilization_usec
+                                                      , size_t duration_usec
+                                                      , size_t jobs_started
+                                                      , size_t is_running
+                                                      , STRING **job_types_names
+                                                      , STRING **job_types_units
+                                                      , WORKER_METRIC_TYPE *job_metric_types
+                                                      , size_t *job_types_jobs_started
+                                                      , usec_t *job_types_busy_time
+                                                      , NETDATA_DOUBLE *job_custom_values
+                                                      )
+                                                      , void *data);
 
 #endif // WORKER_UTILIZATION_H