summaryrefslogtreecommitdiffstats
path: root/database/rrdvar.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2022-11-30 18:47:05 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2022-11-30 18:47:05 +0000
commit97e01009d69b8fbebfebf68f51e3d126d0ed43fc (patch)
tree02e8b836c3a9d89806f3e67d4a5fe9f52dbb0061 /database/rrdvar.c
parentReleasing debian version 1.36.1-1. (diff)
downloadnetdata-97e01009d69b8fbebfebf68f51e3d126d0ed43fc.tar.xz
netdata-97e01009d69b8fbebfebf68f51e3d126d0ed43fc.zip
Merging upstream version 1.37.0.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'database/rrdvar.c')
-rw-r--r--database/rrdvar.c304
1 files changed, 158 insertions, 146 deletions
diff --git a/database/rrdvar.c b/database/rrdvar.c
index d4dda1079..28be4f6a1 100644
--- a/database/rrdvar.c
+++ b/database/rrdvar.c
@@ -1,8 +1,19 @@
// SPDX-License-Identifier: GPL-3.0-or-later
-#define NETDATA_HEALTH_INTERNALS
#include "rrd.h"
+// the variables as stored in the variables indexes
+// there are 3 indexes:
+// 1. at each chart (RRDSET.rrdvar_root_index)
+// 2. at each context (RRDFAMILY.rrdvar_root_index)
+// 3. at each host (RRDHOST.rrdvar_root_index)
+typedef struct rrdvar {
+ STRING *name;
+ void *value;
+ RRDVAR_FLAGS flags:24;
+ RRDVAR_TYPE type:8;
+} RRDVAR;
+
// ----------------------------------------------------------------------------
// RRDVAR management
@@ -20,168 +31,153 @@ inline int rrdvar_fix_name(char *variable) {
return fixed;
}
-int rrdvar_compare(void* a, void* b) {
- if(((RRDVAR *)a)->hash < ((RRDVAR *)b)->hash) return -1;
- else if(((RRDVAR *)a)->hash > ((RRDVAR *)b)->hash) return 1;
- else return strcmp(((RRDVAR *)a)->name, ((RRDVAR *)b)->name);
+inline STRING *rrdvar_name_to_string(const char *name) {
+ char *variable = strdupz(name);
+ rrdvar_fix_name(variable);
+ STRING *name_string = string_strdupz(variable);
+ freez(variable);
+ return name_string;
}
-static inline RRDVAR *rrdvar_index_add(avl_tree_lock *tree, RRDVAR *rv) {
- RRDVAR *ret = (RRDVAR *)avl_insert_lock(tree, (avl_t *)(rv));
- if(ret != rv)
- debug(D_VARIABLES, "Request to insert RRDVAR '%s' into index failed. Already exists.", rv->name);
+struct rrdvar_constructor {
+ STRING *name;
+ void *value;
+ RRDVAR_FLAGS options:16;
+ RRDVAR_TYPE type:8;
- return ret;
-}
+ enum {
+ RRDVAR_REACT_NONE = 0,
+ RRDVAR_REACT_NEW = (1 << 0),
+ } react_action;
+};
+
+static void rrdvar_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, void *rrdvar, void *constructor_data) {
+ RRDVAR *rv = rrdvar;
+ struct rrdvar_constructor *ctr = constructor_data;
-static inline RRDVAR *rrdvar_index_del(avl_tree_lock *tree, RRDVAR *rv) {
- RRDVAR *ret = (RRDVAR *)avl_remove_lock(tree, (avl_t *)(rv));
- if(!ret)
- error("Request to remove RRDVAR '%s' from index failed. Not Found.", rv->name);
+ ctr->options &= ~RRDVAR_OPTIONS_REMOVED_ON_NEW_OBJECTS;
- return ret;
+ rv->name = string_dup(ctr->name);
+ rv->type = ctr->type;
+ rv->flags = ctr->options;
+
+ if(!ctr->value) {
+ NETDATA_DOUBLE *v = mallocz(sizeof(NETDATA_DOUBLE));
+ *v = NAN;
+ rv->value = v;
+ rv->flags |= RRDVAR_FLAG_ALLOCATED;
+ }
+ else
+ rv->value = ctr->value;
+
+ ctr->react_action = RRDVAR_REACT_NEW;
}
-static inline RRDVAR *rrdvar_index_find(avl_tree_lock *tree, const char *name, uint32_t hash) {
- RRDVAR tmp;
- tmp.name = (char *)name;
- tmp.hash = (hash)?hash:simple_hash(tmp.name);
+static void rrdvar_delete_callback(const DICTIONARY_ITEM *item __maybe_unused, void *rrdvar, void *nothing __maybe_unused) {
+ RRDVAR *rv = rrdvar;
- return (RRDVAR *)avl_search_lock(tree, (avl_t *)&tmp);
+ if(rv->flags & RRDVAR_FLAG_ALLOCATED)
+ freez(rv->value);
+
+ string_freez(rv->name);
+ rv->name = NULL;
}
-inline void rrdvar_free(RRDHOST *host, avl_tree_lock *tree, RRDVAR *rv) {
- (void)host;
+DICTIONARY *rrdvariables_create(void) {
+ DICTIONARY *dict = dictionary_create(DICT_OPTION_DONT_OVERWRITE_VALUE);
- if(!rv) return;
+ dictionary_register_insert_callback(dict, rrdvar_insert_callback, NULL);
+ dictionary_register_delete_callback(dict, rrdvar_delete_callback, NULL);
- if(tree) {
- debug(D_VARIABLES, "Deleting variable '%s'", rv->name);
- if(unlikely(!rrdvar_index_del(tree, rv)))
- error("RRDVAR: Attempted to delete variable '%s' from host '%s', but it is not found.", rv->name, host->hostname);
- }
+ return dict;
+}
- if(rv->options & RRDVAR_OPTION_ALLOCATED)
- freez(rv->value);
+void rrdvariables_destroy(DICTIONARY *dict) {
+ dictionary_destroy(dict);
+}
- freez(rv->name);
- freez(rv);
+static inline const RRDVAR_ACQUIRED *rrdvar_get_and_acquire(DICTIONARY *dict, STRING *name) {
+ return (const RRDVAR_ACQUIRED *)dictionary_get_and_acquire_item_advanced(dict, string2str(name), (ssize_t)string_strlen(name) + 1);
}
-inline RRDVAR *rrdvar_create_and_index(const char *scope __maybe_unused, avl_tree_lock *tree, const char *name,
- RRDVAR_TYPE type, RRDVAR_OPTIONS options, void *value) {
- char *variable = strdupz(name);
- rrdvar_fix_name(variable);
- uint32_t hash = simple_hash(variable);
-
- RRDVAR *rv = rrdvar_index_find(tree, variable, hash);
- if(unlikely(!rv)) {
- debug(D_VARIABLES, "Variable '%s' not found in scope '%s'. Creating a new one.", variable, scope);
-
- rv = callocz(1, sizeof(RRDVAR));
- rv->name = variable;
- rv->hash = hash;
- rv->type = type;
- rv->options = options;
- rv->value = value;
- rv->last_updated = now_realtime_sec();
-
- RRDVAR *ret = rrdvar_index_add(tree, rv);
- if(unlikely(ret != rv)) {
- debug(D_VARIABLES, "Variable '%s' in scope '%s' already exists", variable, scope);
- freez(rv);
- freez(variable);
- rv = NULL;
- }
- else
- debug(D_VARIABLES, "Variable '%s' created in scope '%s'", variable, scope);
- }
- else {
- debug(D_VARIABLES, "Variable '%s' is already found in scope '%s'.", variable, scope);
+inline void rrdvar_release_and_del(DICTIONARY *dict, const RRDVAR_ACQUIRED *rva) {
+ if(unlikely(!dict || !rva)) return;
- // already exists
- freez(variable);
+ RRDVAR *rv = dictionary_acquired_item_value((const DICTIONARY_ITEM *)rva);
- // this is important
- // it must return NULL - not the existing variable - or double-free will happen
- rv = NULL;
- }
+ dictionary_del_advanced(dict, string2str(rv->name), (ssize_t)string_strlen(rv->name) + 1);
- return rv;
+ dictionary_acquired_item_release(dict, (const DICTIONARY_ITEM *)rva);
}
-void rrdvar_free_remaining_variables(RRDHOST *host, avl_tree_lock *tree_lock) {
- // This is not bullet proof - avl should support some means to destroy it
- // with a callback for each item already in the index
+inline const RRDVAR_ACQUIRED *rrdvar_add_and_acquire(const char *scope __maybe_unused, DICTIONARY *dict, STRING *name, RRDVAR_TYPE type, RRDVAR_FLAGS options, void *value) {
+ if(unlikely(!dict || !name)) return NULL;
- RRDVAR *rv, *last = NULL;
- while((rv = (RRDVAR *)tree_lock->avl_tree.root)) {
- if(unlikely(rv == last)) {
- error("RRDVAR: INTERNAL ERROR: Cannot cleanup tree of RRDVARs");
- break;
- }
- last = rv;
- rrdvar_free(host, tree_lock, rv);
- }
+ struct rrdvar_constructor tmp = {
+ .name = name,
+ .value = value,
+ .type = type,
+ .options = options,
+ .react_action = RRDVAR_REACT_NONE,
+ };
+ return (const RRDVAR_ACQUIRED *)dictionary_set_and_acquire_item_advanced(dict, string2str(name), (ssize_t)string_strlen(name) + 1, NULL, sizeof(RRDVAR), &tmp);
+}
+
+void rrdvar_delete_all(DICTIONARY *dict) {
+ dictionary_flush(dict);
}
+
// ----------------------------------------------------------------------------
// CUSTOM HOST VARIABLES
-inline int rrdvar_callback_for_all_host_variables(RRDHOST *host, int (*callback)(void * /*rrdvar*/, void * /*data*/), void *data) {
- return avl_traverse_lock(&host->rrdvar_root_index, callback, data);
+inline int rrdvar_walkthrough_read(DICTIONARY *dict, int (*callback)(const DICTIONARY_ITEM *item, void *rrdvar, void *data), void *data) {
+ if(unlikely(!dict)) return 0; // when health is not enabled
+ return dictionary_walkthrough_read(dict, callback, data);
}
-static RRDVAR *rrdvar_custom_variable_create(const char *scope, avl_tree_lock *tree_lock, const char *name) {
- NETDATA_DOUBLE *v = callocz(1, sizeof(NETDATA_DOUBLE));
- *v = NAN;
-
- RRDVAR *rv = rrdvar_create_and_index(scope, tree_lock, name, RRDVAR_TYPE_CALCULATED, RRDVAR_OPTION_CUSTOM_HOST_VAR|RRDVAR_OPTION_ALLOCATED, v);
- if(unlikely(!rv)) {
- freez(v);
- debug(D_VARIABLES, "Requested variable '%s' already exists - possibly 2 plugins are updating it at the same time.", name);
+const RRDVAR_ACQUIRED *rrdvar_custom_host_variable_add_and_acquire(RRDHOST *host, const char *name) {
+ DICTIONARY *dict = host->rrdvars;
+ if(unlikely(!dict)) return NULL; // when health is not enabled
- char *variable = strdupz(name);
- rrdvar_fix_name(variable);
- uint32_t hash = simple_hash(variable);
+ STRING *name_string = rrdvar_name_to_string(name);
- // find the existing one to return it
- rv = rrdvar_index_find(tree_lock, variable, hash);
+ const RRDVAR_ACQUIRED *rva = rrdvar_add_and_acquire("host", dict, name_string, RRDVAR_TYPE_CALCULATED, RRDVAR_FLAG_CUSTOM_HOST_VAR, NULL);
- freez(variable);
- }
-
- return rv;
+ string_freez(name_string);
+ return rva;
}
-RRDVAR *rrdvar_custom_host_variable_create(RRDHOST *host, const char *name) {
- return rrdvar_custom_variable_create("host", &host->rrdvar_root_index, name);
-}
+void rrdvar_custom_host_variable_set(RRDHOST *host, const RRDVAR_ACQUIRED *rva, NETDATA_DOUBLE value) {
+ if(unlikely(!host->rrdvars || !rva)) return; // when health is not enabled
-void rrdvar_custom_host_variable_set(RRDHOST *host, RRDVAR *rv, NETDATA_DOUBLE value) {
- if(rv->type != RRDVAR_TYPE_CALCULATED || !(rv->options & RRDVAR_OPTION_CUSTOM_HOST_VAR) || !(rv->options & RRDVAR_OPTION_ALLOCATED))
- error("requested to set variable '%s' to value " NETDATA_DOUBLE_FORMAT " but the variable is not a custom one.", rv->name, value);
+ if(rrdvar_type(rva) != RRDVAR_TYPE_CALCULATED || !(rrdvar_flags(rva) & (RRDVAR_FLAG_CUSTOM_HOST_VAR | RRDVAR_FLAG_ALLOCATED)))
+ error("requested to set variable '%s' to value " NETDATA_DOUBLE_FORMAT " but the variable is not a custom one.", rrdvar_name(rva), value);
else {
+ RRDVAR *rv = dictionary_acquired_item_value((const DICTIONARY_ITEM *)rva);
NETDATA_DOUBLE *v = rv->value;
if(*v != value) {
*v = value;
- rv->last_updated = now_realtime_sec();
-
// if the host is streaming, send this variable upstream immediately
- rrdpush_sender_send_this_host_variable_now(host, rv);
+ rrdpush_sender_send_this_host_variable_now(host, rva);
}
}
}
-int foreach_host_variable_callback(RRDHOST *host, int (*callback)(RRDVAR * /*rv*/, void * /*data*/), void *data) {
- return avl_traverse_lock(&host->rrdvar_root_index, (int (*)(void *, void *))callback, data);
+void rrdvar_release(DICTIONARY *dict, const RRDVAR_ACQUIRED *rva) {
+ if(unlikely(!dict || !rva)) return; // when health is not enabled
+ dictionary_acquired_item_release(dict, (const DICTIONARY_ITEM *)rva);
}
// ----------------------------------------------------------------------------
// RRDVAR lookup
-NETDATA_DOUBLE rrdvar2number(RRDVAR *rv) {
+NETDATA_DOUBLE rrdvar2number(const RRDVAR_ACQUIRED *rva) {
+ if(unlikely(!rva)) return NAN;
+
+ RRDVAR *rv = dictionary_acquired_item_value((const DICTIONARY_ITEM *)rva);
+
switch(rv->type) {
case RRDVAR_TYPE_CALCULATED: {
NETDATA_DOUBLE *n = (NETDATA_DOUBLE *)rv->value;
@@ -190,17 +186,17 @@ NETDATA_DOUBLE rrdvar2number(RRDVAR *rv) {
case RRDVAR_TYPE_TIME_T: {
time_t *n = (time_t *)rv->value;
- return *n;
+ return (NETDATA_DOUBLE)*n;
}
case RRDVAR_TYPE_COLLECTED: {
collected_number *n = (collected_number *)rv->value;
- return *n;
+ return (NETDATA_DOUBLE)*n;
}
case RRDVAR_TYPE_TOTAL: {
total_number *n = (total_number *)rv->value;
- return *n;
+ return (NETDATA_DOUBLE)*n;
}
case RRDVAR_TYPE_INT: {
@@ -214,28 +210,31 @@ NETDATA_DOUBLE rrdvar2number(RRDVAR *rv) {
}
}
-int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, NETDATA_DOUBLE *result) {
+int health_variable_lookup(STRING *variable, RRDCALC *rc, NETDATA_DOUBLE *result) {
RRDSET *st = rc->rrdset;
if(!st) return 0;
RRDHOST *host = st->rrdhost;
- RRDVAR *rv;
+ const RRDVAR_ACQUIRED *rva;
- rv = rrdvar_index_find(&st->rrdvar_root_index, variable, hash);
- if(rv) {
- *result = rrdvar2number(rv);
+ rva = rrdvar_get_and_acquire(st->rrdvars, variable);
+ if(rva) {
+ *result = rrdvar2number(rva);
+ dictionary_acquired_item_release(st->rrdvars, (const DICTIONARY_ITEM *)rva);
return 1;
}
- rv = rrdvar_index_find(&st->rrdfamily->rrdvar_root_index, variable, hash);
- if(rv) {
- *result = rrdvar2number(rv);
+ rva = rrdvar_get_and_acquire(rrdfamily_rrdvars_dict(st->rrdfamily), variable);
+ if(rva) {
+ *result = rrdvar2number(rva);
+ dictionary_acquired_item_release(rrdfamily_rrdvars_dict(st->rrdfamily), (const DICTIONARY_ITEM *)rva);
return 1;
}
- rv = rrdvar_index_find(&host->rrdvar_root_index, variable, hash);
- if(rv) {
- *result = rrdvar2number(rv);
+ rva = rrdvar_get_and_acquire(host->rrdvars, variable);
+ if(rva) {
+ *result = rrdvar2number(rva);
+ dictionary_acquired_item_release(host->rrdvars, (const DICTIONARY_ITEM *)rva);
return 1;
}
@@ -248,19 +247,19 @@ int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, NET
struct variable2json_helper {
BUFFER *buf;
size_t counter;
- RRDVAR_OPTIONS options;
+ RRDVAR_FLAGS options;
};
-static int single_variable2json(void *entry, void *data) {
- struct variable2json_helper *helper = (struct variable2json_helper *)data;
- RRDVAR *rv = (RRDVAR *)entry;
- NETDATA_DOUBLE value = rrdvar2number(rv);
+static int single_variable2json_callback(const DICTIONARY_ITEM *item __maybe_unused, void *entry __maybe_unused, void *helper_data) {
+ struct variable2json_helper *helper = (struct variable2json_helper *)helper_data;
+ const RRDVAR_ACQUIRED *rva = (const RRDVAR_ACQUIRED *)item;
+ NETDATA_DOUBLE value = rrdvar2number(rva);
- if (helper->options == RRDVAR_OPTION_DEFAULT || rv->options & helper->options) {
+ if (helper->options == RRDVAR_FLAG_NONE || rrdvar_flags(rva) & helper->options) {
if(unlikely(isnan(value) || isinf(value)))
- buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": null", helper->counter?",":"", rv->name);
+ buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": null", helper->counter?",":"", rrdvar_name(rva));
else
- buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": %0.5" NETDATA_DOUBLE_MODIFIER, helper->counter?",":"", rv->name, (NETDATA_DOUBLE)value);
+ buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": %0.5" NETDATA_DOUBLE_MODIFIER, helper->counter?",":"", rrdvar_name(rva), (NETDATA_DOUBLE)value);
helper->counter++;
}
@@ -272,11 +271,10 @@ void health_api_v1_chart_custom_variables2json(RRDSET *st, BUFFER *buf) {
struct variable2json_helper helper = {
.buf = buf,
.counter = 0,
- .options = RRDVAR_OPTION_CUSTOM_CHART_VAR
- };
+ .options = RRDVAR_FLAG_CUSTOM_CHART_VAR};
buffer_sprintf(buf, "{");
- avl_traverse_lock(&st->rrdvar_root_index, single_variable2json, (void *)&helper);
+ rrdvar_walkthrough_read(st->rrdvars, single_variable2json_callback, &helper);
buffer_strcat(buf, "\n\t\t\t}");
}
@@ -286,20 +284,34 @@ void health_api_v1_chart_variables2json(RRDSET *st, BUFFER *buf) {
struct variable2json_helper helper = {
.buf = buf,
.counter = 0,
- .options = RRDVAR_OPTION_DEFAULT
- };
+ .options = RRDVAR_FLAG_NONE};
- buffer_sprintf(buf, "{\n\t\"chart\": \"%s\",\n\t\"chart_name\": \"%s\",\n\t\"chart_context\": \"%s\",\n\t\"chart_variables\": {", st->id, st->name, st->context);
- avl_traverse_lock(&st->rrdvar_root_index, single_variable2json, (void *)&helper);
+ buffer_sprintf(buf, "{\n\t\"chart\": \"%s\",\n\t\"chart_name\": \"%s\",\n\t\"chart_context\": \"%s\",\n\t\"chart_variables\": {", rrdset_id(st), rrdset_name(st), rrdset_context(st));
+ rrdvar_walkthrough_read(st->rrdvars, single_variable2json_callback, &helper);
- buffer_sprintf(buf, "\n\t},\n\t\"family\": \"%s\",\n\t\"family_variables\": {", st->family);
+ buffer_sprintf(buf, "\n\t},\n\t\"family\": \"%s\",\n\t\"family_variables\": {", rrdset_family(st));
helper.counter = 0;
- avl_traverse_lock(&st->rrdfamily->rrdvar_root_index, single_variable2json, (void *)&helper);
+ rrdvar_walkthrough_read(rrdfamily_rrdvars_dict(st->rrdfamily), single_variable2json_callback, &helper);
- buffer_sprintf(buf, "\n\t},\n\t\"host\": \"%s\",\n\t\"host_variables\": {", host->hostname);
+ buffer_sprintf(buf, "\n\t},\n\t\"host\": \"%s\",\n\t\"host_variables\": {", rrdhost_hostname(host));
helper.counter = 0;
- avl_traverse_lock(&host->rrdvar_root_index, single_variable2json, (void *)&helper);
+ rrdvar_walkthrough_read(host->rrdvars, single_variable2json_callback, &helper);
buffer_strcat(buf, "\n\t}\n}\n");
}
+// ----------------------------------------------------------------------------
+// RRDVAR private members examination
+
+const char *rrdvar_name(const RRDVAR_ACQUIRED *rva) {
+ return dictionary_acquired_item_name((const DICTIONARY_ITEM *)rva);
+}
+
+RRDVAR_FLAGS rrdvar_flags(const RRDVAR_ACQUIRED *rva) {
+ RRDVAR *rv = dictionary_acquired_item_value((const DICTIONARY_ITEM *)rva);
+ return rv->flags;
+}
+RRDVAR_TYPE rrdvar_type(const RRDVAR_ACQUIRED *rva) {
+ RRDVAR *rv = dictionary_acquired_item_value((const DICTIONARY_ITEM *)rva);
+ return rv->type;
+}