Merging upstream version 1.37.0.

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

1 files changed, 141 insertions, 175 deletions

diff --git a/health/health_log.c b/health/health_log.c
index f0a05531d..8105e01ae 100644
--- a/health/health_log.c
+++ b/health/health_log.c
@@ -14,11 +14,11 @@ inline int health_alarm_log_open(RRDHOST *host) {
 
     if(host->health_log_fp) {
         if (setvbuf(host->health_log_fp, NULL, _IOLBF, 0) != 0)
-            error("HEALTH [%s]: cannot set line buffering on health log file '%s'.", host->hostname, host->health_log_filename);
+            error("HEALTH [%s]: cannot set line buffering on health log file '%s'.", rrdhost_hostname(host), host->health_log_filename);
         return 0;
     }
 
-    error("HEALTH [%s]: cannot open health log file '%s'. Health data will be lost in case of netdata or server crash.", host->hostname, host->health_log_filename);
+    error("HEALTH [%s]: cannot open health log file '%s'. Health data will be lost in case of netdata or server crash.", rrdhost_hostname(host), host->health_log_filename);
     return -1;
 }
 
@@ -45,13 +45,13 @@ static inline void health_log_rotate(RRDHOST *host) {
             snprintfz(old_filename, FILENAME_MAX, "%s.old", host->health_log_filename);
 
             if(unlink(old_filename) == -1 && errno != ENOENT)
-                error("HEALTH [%s]: cannot remove old alarms log file '%s'", host->hostname, old_filename);
+                error("HEALTH [%s]: cannot remove old alarms log file '%s'", rrdhost_hostname(host), old_filename);
 
             if(link(host->health_log_filename, old_filename) == -1 && errno != ENOENT)
-                error("HEALTH [%s]: cannot move file '%s' to '%s'.", host->hostname, host->health_log_filename, old_filename);
+                error("HEALTH [%s]: cannot move file '%s' to '%s'.", rrdhost_hostname(host), host->health_log_filename, old_filename);
 
             if(unlink(host->health_log_filename) == -1 && errno != ENOENT)
-                error("HEALTH [%s]: cannot remove old alarms log file '%s'", host->hostname, host->health_log_filename);
+                error("HEALTH [%s]: cannot remove old alarms log file '%s'", rrdhost_hostname(host), host->health_log_filename);
 
             // open it with truncate
             host->health_log_fp = fopen(host->health_log_filename, "w");
@@ -59,7 +59,7 @@ static inline void health_log_rotate(RRDHOST *host) {
             if(host->health_log_fp)
                 fclose(host->health_log_fp);
             else
-                error("HEALTH [%s]: cannot truncate health log '%s'", host->hostname, host->health_log_filename);
+                error("HEALTH [%s]: cannot truncate health log '%s'", rrdhost_hostname(host), host->health_log_filename);
 
             host->health_log_fp = NULL;
 
@@ -75,12 +75,12 @@ inline void health_label_log_save(RRDHOST *host) {
     if(unlikely(host->health_log_fp)) {
         BUFFER *wb = buffer_create(1024);
 
-        rrdlabels_to_buffer(localhost->host_labels, wb, "", "=", "", "\t ", NULL, NULL, NULL, NULL);
+        rrdlabels_to_buffer(localhost->rrdlabels, wb, "", "=", "", "\t ", NULL, NULL, NULL, NULL);
         char *write = (char *) buffer_tostring(wb);
 
         if (unlikely(fprintf(host->health_log_fp, "L\t%s", write) < 0))
             error("HEALTH [%s]: failed to save alarm log entry to '%s'. Health data may be lost in case of abnormal restart.",
-                  host->hostname, host->health_log_filename);
+                  rrdhost_hostname(host), host->health_log_filename);
         else
             host->health_log_entries_written++;
 
@@ -103,7 +103,7 @@ inline void health_alarm_log_save(RRDHOST *host, ALARM_ENTRY *ae) {
                         "\t%s\t%s\t%s"
                         "\n"
                             , (ae->flags & HEALTH_ENTRY_FLAG_SAVED)?'U':'A'
-                            , host->hostname
+                            , rrdhost_hostname(host)
 
                             , ae->unique_id
                             , ae->alarm_id
@@ -118,14 +118,14 @@ inline void health_alarm_log_save(RRDHOST *host, ALARM_ENTRY *ae) {
                             , (uint32_t)ae->exec_run_timestamp
                             , (uint32_t)ae->delay_up_to_timestamp
 
-                            , (ae->name)?ae->name:""
-                            , (ae->chart)?ae->chart:""
-                            , (ae->family)?ae->family:""
-                            , (ae->exec)?ae->exec:""
-                            , (ae->recipient)?ae->recipient:""
-                            , (ae->source)?ae->source:""
-                            , (ae->units)?ae->units:""
-                            , (ae->info)?ae->info:""
+                            , ae_name(ae)
+                            , ae_chart_name(ae)
+                            , ae_family(ae)
+                            , ae_exec(ae)
+                            , ae_recipient(ae)
+                            , ae_source(ae)
+                            , ae_units(ae)
+                            , ae_info(ae)
 
                             , ae->exec_code
                             , ae->new_status
@@ -135,11 +135,11 @@ inline void health_alarm_log_save(RRDHOST *host, ALARM_ENTRY *ae) {
                             , ae->new_value
                             , ae->old_value
                             , (uint64_t)ae->last_repeat
-                            , (ae->classification)?ae->classification:"Unknown"
-                            , (ae->component)?ae->component:"Unknown"
-                            , (ae->type)?ae->type:"Unknown"
+                            , (ae->classification)?ae_classification(ae):"Unknown"
+                            , (ae->component)?ae_component(ae):"Unknown"
+                            , (ae->type)?ae_type(ae):"Unknown"
         ) < 0))
-            error("HEALTH [%s]: failed to save alarm log entry to '%s'. Health data may be lost in case of abnormal restart.", host->hostname, host->health_log_filename);
+            error("HEALTH [%s]: failed to save alarm log entry to '%s'. Health data may be lost in case of abnormal restart.", rrdhost_hostname(host), host->health_log_filename);
         else {
             ae->flags |= HEALTH_ENTRY_FLAG_SAVED;
             host->health_log_entries_written++;
@@ -156,18 +156,23 @@ inline void health_alarm_log_save(RRDHOST *host, ALARM_ENTRY *ae) {
 
 static uint32_t is_valid_alarm_id(RRDHOST *host, const char *chart, const char *name, uint32_t alarm_id)
 {
-    uint32_t hash_chart = simple_hash(chart);
-    uint32_t hash_name = simple_hash(name);
+    STRING *chart_string = string_strdupz(chart);
+    STRING *name_string = string_strdupz(name);
+
+    uint32_t ret = 1;
 
     ALARM_ENTRY *ae;
     for(ae = host->health_log.alarms; ae ;ae = ae->next) {
-        if (unlikely(
-                ae->alarm_id == alarm_id && (!(ae->hash_name == hash_name && ae->hash_chart == hash_chart &&
-                                               !strcmp(name, ae->name) && !strcmp(chart, ae->chart))))) {
-            return 0;
+        if (unlikely(ae->alarm_id == alarm_id && (!(chart_string == ae->chart && name_string == ae->name)))) {
+            ret = 0;
+            break;
         }
     }
-    return 1;
+
+    string_freez(chart_string);
+    string_freez(name_string);
+
+    return ret;
 }
 
 static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char *filename) {
@@ -177,6 +182,14 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
     size_t line = 0, len = 0;
     ssize_t loaded = 0, updated = 0, errored = 0, duplicate = 0;
 
+    DICTIONARY *all_rrdcalcs = dictionary_create(
+        DICT_OPTION_NAME_LINK_DONT_CLONE | DICT_OPTION_VALUE_LINK_DONT_CLONE | DICT_OPTION_DONT_OVERWRITE_VALUE);
+    RRDCALC *rc;
+    foreach_rrdcalc_in_rrdhost_read(host, rc) {
+        dictionary_set(all_rrdcalcs, rrdcalc_name(rc), rc, sizeof(*rc));
+    }
+    foreach_rrdcalc_in_rrdhost_done(rc);
+
     netdata_rwlock_rdlock(&host->health_log.alarm_log_rwlock);
 
     while((s = fgets_trim_len(buf, 65536, fp, &len))) {
@@ -192,7 +205,7 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
                 *s = '\0';
                 pointers[entries++] = ++s;
                 if(entries >= max_entries) {
-                    error("HEALTH [%s]: line %zu of file '%s' has more than %d entries. Ignoring excessive entries.", host->hostname, line, filename, max_entries);
+                    error("HEALTH [%s]: line %zu of file '%s' has more than %d entries. Ignoring excessive entries.", rrdhost_hostname(host), line, filename, max_entries);
                     break;
                 }
             }
@@ -206,7 +219,7 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
             ALARM_ENTRY *ae = NULL;
 
             if(entries < 27) {
-                error("HEALTH [%s]: line %zu of file '%s' should have at least 27 entries, but it has %d. Ignoring it.", host->hostname, line, filename, entries);
+                error("HEALTH [%s]: line %zu of file '%s' should have at least 27 entries, but it has %d. Ignoring it.", rrdhost_hostname(host), line, filename, entries);
                 errored++;
                 continue;
             }
@@ -214,14 +227,14 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
             // check that we have valid ids
             uint32_t unique_id = (uint32_t)strtoul(pointers[2], NULL, 16);
             if(!unique_id) {
-                error("HEALTH [%s]: line %zu of file '%s' states alarm entry with invalid unique id %u (%s). Ignoring it.", host->hostname, line, filename, unique_id, pointers[2]);
+                error("HEALTH [%s]: line %zu of file '%s' states alarm entry with invalid unique id %u (%s). Ignoring it.", rrdhost_hostname(host), line, filename, unique_id, pointers[2]);
                 errored++;
                 continue;
             }
 
             uint32_t alarm_id = (uint32_t)strtoul(pointers[3], NULL, 16);
             if(!alarm_id) {
-                error("HEALTH [%s]: line %zu of file '%s' states alarm entry for invalid alarm id %u (%s). Ignoring it.", host->hostname, line, filename, alarm_id, pointers[3]);
+                error("HEALTH [%s]: line %zu of file '%s' states alarm entry for invalid alarm id %u (%s). Ignoring it.", rrdhost_hostname(host), line, filename, alarm_id, pointers[3]);
                 errored++;
                 continue;
             }
@@ -232,18 +245,7 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
                 char* alarm_name = pointers[13];
                 last_repeat = (time_t)strtoul(pointers[27], NULL, 16);
 
-                RRDCALC *rc = alarm_max_last_repeat(host, alarm_name,simple_hash(alarm_name));
-                if (!rc) {
-                    for(rc = host->alarms; rc ; rc = rc->next) {
-                        RRDCALC *rdcmp  = (RRDCALC *) avl_insert_lock(&(host)->alarms_idx_name, (avl_t *)rc);
-                        if(rdcmp != rc) {
-                            error("Cannot insert the alarm index ID using log %s", rc->name);
-                        }
-                    }
-
-                    rc = alarm_max_last_repeat(host, alarm_name,simple_hash(alarm_name));
-                }
-
+                rc = dictionary_get(all_rrdcalcs, alarm_name);
                 if(unlikely(rc)) {
                     if (rrdcalc_isrepeating(rc)) {
                         rc->last_repeat = last_repeat;
@@ -259,7 +261,7 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
                 // make sure it is properly numbered
                 if(unlikely(host->health_log.alarms && unique_id < host->health_log.alarms->unique_id)) {
                     error( "HEALTH [%s]: line %zu of file '%s' has alarm log entry %u in wrong order. Ignoring it."
-                           , host->hostname, line, filename, unique_id);
+                           , rrdhost_hostname(host), line, filename, unique_id);
                     errored++;
                     continue;
                 }
@@ -272,7 +274,7 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
                     if(unlikely(unique_id == ae->unique_id)) {
                         if(unlikely(*pointers[0] == 'A')) {
                             error("HEALTH [%s]: line %zu of file '%s' adds duplicate alarm log entry %u. Using the later."
-                            , host->hostname, line, filename, unique_id);
+                            , rrdhost_hostname(host), line, filename, unique_id);
                             *pointers[0] = 'U';
                             duplicate++;
                         }
@@ -298,8 +300,13 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
             //    error("HEALTH [%s]: line %zu of file '%s' provides an alarm for host '%s' but this is named '%s'.", host->hostname, line, filename, pointers[1], host->hostname);
 
             ae->unique_id               = unique_id;
-            if (!is_valid_alarm_id(host, pointers[14], pointers[13], alarm_id))
-                alarm_id = rrdcalc_get_unique_id(host, pointers[14], pointers[13], NULL);
+            if (!is_valid_alarm_id(host, pointers[14], pointers[13], alarm_id)) {
+                STRING *chart = string_strdupz(pointers[14]);
+                STRING *name = string_strdupz(pointers[13]);
+                alarm_id = rrdcalc_get_unique_id(host, chart, name, NULL);
+                string_freez(chart);
+                string_freez(name);
+            }
             ae->alarm_id                = alarm_id;
             ae->alarm_event_id          = (uint32_t)strtoul(pointers[4], NULL, 16);
             ae->updated_by_id           = (uint32_t)strtoul(pointers[5], NULL, 16);
@@ -315,36 +322,29 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
             ae->exec_run_timestamp      = (uint32_t)strtoul(pointers[11], NULL, 16);
             ae->delay_up_to_timestamp   = (uint32_t)strtoul(pointers[12], NULL, 16);
 
-            freez(ae->name);
-            ae->name = strdupz(pointers[13]);
-            ae->hash_name = simple_hash(ae->name);
+            string_freez(ae->name);
+            ae->name = string_strdupz(pointers[13]);
 
-            freez(ae->chart);
-            ae->chart = strdupz(pointers[14]);
-            ae->hash_chart = simple_hash(ae->chart);
+            string_freez(ae->chart);
+            ae->chart = string_strdupz(pointers[14]);
 
-            freez(ae->family);
-            ae->family = strdupz(pointers[15]);
+            string_freez(ae->family);
+            ae->family = string_strdupz(pointers[15]);
 
-            freez(ae->exec);
-            ae->exec = strdupz(pointers[16]);
-            if(!*ae->exec) { freez(ae->exec); ae->exec = NULL; }
+            string_freez(ae->exec);
+            ae->exec = string_strdupz(pointers[16]);
 
-            freez(ae->recipient);
-            ae->recipient = strdupz(pointers[17]);
-            if(!*ae->recipient) { freez(ae->recipient); ae->recipient = NULL; }
+            string_freez(ae->recipient);
+            ae->recipient = string_strdupz(pointers[17]);
 
-            freez(ae->source);
-            ae->source = strdupz(pointers[18]);
-            if(!*ae->source) { freez(ae->source); ae->source = NULL; }
+            string_freez(ae->source);
+            ae->source = string_strdupz(pointers[18]);
 
-            freez(ae->units);
-            ae->units = strdupz(pointers[19]);
-            if(!*ae->units) { freez(ae->units); ae->units = NULL; }
+            string_freez(ae->units);
+            ae->units = string_strdupz(pointers[19]);
 
-            freez(ae->info);
-            ae->info = strdupz(pointers[20]);
-            if(!*ae->info) { freez(ae->info); ae->info = NULL; }
+            string_freez(ae->info);
+            ae->info = string_strdupz(pointers[20]);
 
             ae->exec_code   = str2i(pointers[21]);
             ae->new_status  = str2i(pointers[22]);
@@ -357,24 +357,21 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
             ae->last_repeat = last_repeat;
 
             if (likely(entries > 30)) {
-                freez(ae->classification);
-                ae->classification = strdupz(pointers[28]);
-                if(!*ae->classification) { freez(ae->classification); ae->classification = NULL; }
+                string_freez(ae->classification);
+                ae->classification = string_strdupz(pointers[28]);
 
-                freez(ae->component);
-                ae->component = strdupz(pointers[29]);
-                if(!*ae->component) { freez(ae->component); ae->component = NULL; }
+                string_freez(ae->component);
+                ae->component = string_strdupz(pointers[29]);
 
-                freez(ae->type);
-                ae->type = strdupz(pointers[30]);
-                if(!*ae->type) { freez(ae->type); ae->type = NULL; }
+                string_freez(ae->type);
+                ae->type = string_strdupz(pointers[30]);
             }
 
             char value_string[100 + 1];
-            freez(ae->old_value_string);
-            freez(ae->new_value_string);
-            ae->old_value_string = strdupz(format_value_and_unit(value_string, 100, ae->old_value, ae->units, -1));
-            ae->new_value_string = strdupz(format_value_and_unit(value_string, 100, ae->new_value, ae->units, -1));
+            string_freez(ae->old_value_string);
+            string_freez(ae->new_value_string);
+            ae->old_value_string = string_strdupz(format_value_and_unit(value_string, 100, ae->old_value, ae_units(ae), -1));
+            ae->new_value_string = string_strdupz(format_value_and_unit(value_string, 100, ae->new_value, ae_units(ae), -1));
 
             // add it to host if not already there
             if(unlikely(*pointers[0] == 'A')) {
@@ -395,13 +392,16 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
                 host->health_max_alarm_id = ae->alarm_id;
         }
         else {
-            error("HEALTH [%s]: line %zu of file '%s' is invalid (unrecognized entry type '%s').", host->hostname, line, filename, pointers[0]);
+            error("HEALTH [%s]: line %zu of file '%s' is invalid (unrecognized entry type '%s').", rrdhost_hostname(host), line, filename, pointers[0]);
             errored++;
         }
     }
 
     netdata_rwlock_unlock(&host->health_log.alarm_log_rwlock);
 
+    dictionary_destroy(all_rrdcalcs);
+    all_rrdcalcs = NULL;
+
     freez(buf);
 
     if(!host->health_max_unique_id) host->health_max_unique_id = (uint32_t)now_realtime_sec();
@@ -411,7 +411,7 @@ static inline ssize_t health_alarm_log_read(RRDHOST *host, FILE *fp, const char
     if (unlikely(!host->health_log.next_alarm_id || host->health_log.next_alarm_id <= host->health_max_alarm_id))
         host->health_log.next_alarm_id = host->health_max_alarm_id + 1;
 
-    debug(D_HEALTH, "HEALTH [%s]: loaded file '%s' with %zd new alarm entries, updated %zd alarms, errors %zd entries, duplicate %zd", host->hostname, filename, loaded, updated, errored, duplicate);
+    debug(D_HEALTH, "HEALTH [%s]: loaded file '%s' with %zd new alarm entries, updated %zd alarms, errors %zd entries, duplicate %zd", rrdhost_hostname(host), filename, loaded, updated, errored, duplicate);
     return loaded;
 }
 
@@ -422,7 +422,7 @@ inline void health_alarm_log_load(RRDHOST *host) {
     snprintfz(filename, FILENAME_MAX, "%s.old", host->health_log_filename);
     FILE *fp = fopen(filename, "r");
     if(!fp)
-        error("HEALTH [%s]: cannot open health file: %s", host->hostname, filename);
+        error("HEALTH [%s]: cannot open health file: %s", rrdhost_hostname(host), filename);
     else {
         health_alarm_log_read(host, fp, filename);
         fclose(fp);
@@ -431,7 +431,7 @@ inline void health_alarm_log_load(RRDHOST *host) {
     host->health_log_entries_written = 0;
     fp = fopen(host->health_log_filename, "r");
     if(!fp)
-        error("HEALTH [%s]: cannot open health file: %s", host->hostname, host->health_log_filename);
+        error("HEALTH [%s]: cannot open health file: %s", rrdhost_hostname(host), host->health_log_filename);
     else {
         health_alarm_log_read(host, fp, host->health_log_filename);
         fclose(fp);
@@ -443,63 +443,48 @@ inline void health_alarm_log_load(RRDHOST *host) {
 // health alarm log management
 
 inline ALARM_ENTRY* health_create_alarm_entry(
-        RRDHOST *host,
-        uint32_t alarm_id,
-        uint32_t alarm_event_id,
-        uuid_t config_hash_id,
-        time_t when,
-        const char *name,
-        const char *chart,
-        const char *chart_context,
-        const char *family,
-        const char *class,
-        const char *component,
-        const char *type,
-        const char *exec,
-        const char *recipient,
-        time_t duration,
-        NETDATA_DOUBLE old_value,
-        NETDATA_DOUBLE new_value,
-        RRDCALC_STATUS old_status,
-        RRDCALC_STATUS new_status,
-        const char *source,
-        const char *units,
-        const char *info,
-        int delay,
-        uint32_t flags
+    RRDHOST *host,
+    uint32_t alarm_id,
+    uint32_t alarm_event_id,
+    const uuid_t config_hash_id,
+    time_t when,
+    STRING *name,
+    STRING *chart,
+    STRING *chart_context,
+    STRING *family,
+    STRING *class,
+    STRING *component,
+    STRING *type,
+    STRING *exec,
+    STRING *recipient,
+    time_t duration,
+    NETDATA_DOUBLE old_value,
+    NETDATA_DOUBLE new_value,
+    RRDCALC_STATUS old_status,
+    RRDCALC_STATUS new_status,
+    STRING *source,
+    STRING *units,
+    STRING *info,
+    int delay,
+    uint32_t flags
 ) {
     debug(D_HEALTH, "Health adding alarm log entry with id: %u", host->health_log.next_log_id);
 
     ALARM_ENTRY *ae = callocz(1, sizeof(ALARM_ENTRY));
-    ae->name = strdupz(name);
-    ae->hash_name = simple_hash(ae->name);
-
-    if(chart) {
-        ae->chart = strdupz(chart);
-        ae->hash_chart = simple_hash(ae->chart);
-    }
-
-    if(chart_context)
-        ae->chart_context = strdupz(chart_context);
+    ae->name = string_dup(name);
+    ae->chart = string_dup(chart);
+    ae->chart_context = string_dup(chart_context);
 
     uuid_copy(ae->config_hash_id, *((uuid_t *) config_hash_id));
 
-    if(family)
-        ae->family = strdupz(family);
-
-    if (class)
-        ae->classification = strdupz(class);
-
-    if (component)
-        ae->component = strdupz(component);
-
-    if (type)
-        ae->type = strdupz(type);
-
-    if(exec) ae->exec = strdupz(exec);
-    if(recipient) ae->recipient = strdupz(recipient);
-    if(source) ae->source = strdupz(source);
-    if(units) ae->units = strdupz(units);
+    ae->family = string_dup(family);
+    ae->classification = string_dup(class);
+    ae->component = string_dup(component);
+    ae->type = string_dup(type);
+    ae->exec = string_dup(exec);
+    ae->recipient = string_dup(recipient);
+    ae->source = string_dup(source);
+    ae->units = string_dup(units);
 
     ae->unique_id = host->health_log.next_log_id++;
     ae->alarm_id = alarm_id;
@@ -509,27 +494,10 @@ inline ALARM_ENTRY* health_create_alarm_entry(
     ae->new_value = new_value;
 
     char value_string[100 + 1];
-    ae->old_value_string = strdupz(format_value_and_unit(value_string, 100, ae->old_value, ae->units, -1));
-    ae->new_value_string = strdupz(format_value_and_unit(value_string, 100, ae->new_value, ae->units, -1));
-
-    char *replaced_info = NULL;
-    if (likely(info)) {
-        char *m;
-        replaced_info = strdupz(info);
-        size_t pos = 0;
-        while ((m = strstr(replaced_info + pos, "$family"))) {
-            char *buf = NULL;
-            pos = m - replaced_info;
-            buf = find_and_replace(replaced_info, "$family", (ae->family) ? ae->family : "", m);
-            freez(replaced_info);
-            replaced_info = strdupz(buf);
-            freez(buf);
-        }
-    }
-
-    if(replaced_info) ae->info = strdupz(replaced_info);
-    freez(replaced_info);
+    ae->old_value_string = string_strdupz(format_value_and_unit(value_string, 100, ae->old_value, ae_units(ae), -1));
+    ae->new_value_string = string_strdupz(format_value_and_unit(value_string, 100, ae->new_value, ae_units(ae), -1));
 
+    ae->info = string_dup(info);
     ae->old_status = old_status;
     ae->new_status = new_status;
     ae->duration = duration;
@@ -545,7 +513,7 @@ inline ALARM_ENTRY* health_create_alarm_entry(
     return ae;
 }
 
-inline void health_alarm_log(
+inline void health_alarm_log_add_entry(
         RRDHOST *host,
         ALARM_ENTRY *ae
 ) {
@@ -585,26 +553,24 @@ inline void health_alarm_log(
 }
 
 inline void health_alarm_log_free_one_nochecks_nounlink(ALARM_ENTRY *ae) {
-    freez(ae->name);
-    freez(ae->chart);
-    freez(ae->chart_context);
-    freez(ae->family);
-    freez(ae->classification);
-    freez(ae->component);
-    freez(ae->type);
-    freez(ae->exec);
-    freez(ae->recipient);
-    freez(ae->source);
-    freez(ae->units);
-    freez(ae->info);
-    freez(ae->old_value_string);
-    freez(ae->new_value_string);
+    string_freez(ae->name);
+    string_freez(ae->chart);
+    string_freez(ae->chart_context);
+    string_freez(ae->family);
+    string_freez(ae->classification);
+    string_freez(ae->component);
+    string_freez(ae->type);
+    string_freez(ae->exec);
+    string_freez(ae->recipient);
+    string_freez(ae->source);
+    string_freez(ae->units);
+    string_freez(ae->info);
+    string_freez(ae->old_value_string);
+    string_freez(ae->new_value_string);
     freez(ae);
 }
 
 inline void health_alarm_log_free(RRDHOST *host) {
-    rrdhost_check_wrlock(host);
-
     netdata_rwlock_wrlock(&host->health_log.alarm_log_rwlock);
 
     ALARM_ENTRY *ae;