ifndef BIN_DIR
-BIN_DIR = "$(PWD)"
+BIN_DIR = "."
endif
ifndef CONFIG_DIR
COMMON_FLAGS = BIN_DIR='$(BIN_DIR)' CONFIG_DIR='$(CONFIG_DIR)' LOG_DIR='$(LOG_DIR)' PLUGINS_DIR='$(PLUGINS_DIR)'
+proc_sources = proc_net_dev.c proc_net_ip_vs_stats.c proc_diskstats.c proc_meminfo.c proc_net_netstat.c proc_net_snmp.c proc_net_stat_conntrack.c proc_stat.c proc_vmstat.c proc_net_rpc_nfsd.c
+sources = avl.c procfile.c common.c log.c popen.c url.c config.c web_buffer.c storage_number.c web_client.c global_statistics.c rrd.c rrd2json.c web_server.c plugins_d.c daemon.c plugin_tc.c plugin_checks.c plugin_idlejitter.c plugin_proc.c unit_test.c main.c
+libs = -pthread -lz
+
ifdef debug
COMMON_FLAGS += debug=1
-CFLAGS = -Wall -Wextra -ggdb -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)'
+CFLAGS = -Wall -Wextra -O -ggdb -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)' -fno-omit-frame-pointer
+# CFLAGS := -Wall -Wextra -O -g -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)' -fsanitize=thread -fno-omit-frame-pointer -fPIE
+# libs += -pie -ltsan
else
-CFLAGS = -Wall -Wextra -O3 -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)'
+CFLAGS := -Wall -Wextra -O3 -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)' -fomit-frame-pointer
endif
CC = gcc
-proc_sources = proc_net_dev.c proc_net_ip_vs_stats.c proc_diskstats.c proc_meminfo.c proc_net_netstat.c proc_net_snmp.c proc_net_stat_conntrack.c proc_stat.c proc_vmstat.c proc_net_rpc_nfsd.c
-sources = procfile.c common.c log.c popen.c url.c config.c web_buffer.c storage_number.c web_client.c global_statistics.c rrd.c rrd2json.c web_server.c plugins_d.c daemon.c plugin_tc.c plugin_checks.c plugin_idlejitter.c plugin_proc.c unit_test.c main.c
-libs = -pthread -lz
-
ifdef STORAGE_WITH_MATH
CFLAGS += -DSTORAGE_WITH_MATH=1
libs += -lm
all: show_options netdata plugins
%.o: %.c ${headers}
- @echo " $(CC) $<"
- @$(CC) $(CFLAGS) -c $< -o $@
+ $(CC) $(CFLAGS) -c $< -o $@
netdata: $(objects)
- @echo " $(CC) netdata"
- @$(CC) -o netdata $(objects) $(libs)
+ $(CC) -o netdata $(objects) $(libs)
show_options:
@echo " COMPILING WITH OPTIONS: $(CFLAGS)"
--- /dev/null
+/*
+ * ANSI C Library for maintainance of AVL Balanced Trees
+ *
+ * ref.:
+ * G. M. Adelson-Velskij & E. M. Landis
+ * Doklady Akad. Nauk SSSR 146 (1962), 263-266
+ *
+ * see also:
+ * D. E. Knuth: The Art of Computer Programming Vol.3 (Sorting and Searching)
+ *
+ * (C) 2000 Daniel Nagy, Budapest University of Technology and Economics
+ * Released under GNU General Public License (GPL) version 2
+ *
+ */
+
+#include "avl.h"
+
+/* Private methods */
+
+/* Swing to the left
+ * Warning: no balance maintainance
+ */
+void avl_swl(avl** root) {
+ avl* a = *root;
+ avl* b = a->right;
+ *root = b;
+ a->right = b->left;
+ b->left = a;
+}
+
+/* Swing to the right
+ * Warning: no balance maintainance
+ */
+void avl_swr(avl** root) {
+ avl* a = *root;
+ avl* b = a->left;
+ *root = b;
+ a->left = b->right;
+ b->right = a;
+}
+
+/* Balance maintainance after especially nasty swings
+ */
+void avl_nasty(avl* root) {
+ switch (root->balance) {
+ case -1:
+ root->left->balance = 0;
+ root->right->balance = 1;
+ break;
+ case 1:
+ root->left->balance = -1;
+ root->right->balance = 0;
+ break;
+ case 0:
+ root->left->balance = 0;
+ root->right->balance = 0;
+ }
+ root->balance = 0;
+}
+
+/* Public methods */
+
+/* Insert element a into the AVL tree t
+ * returns 1 if the depth of the tree has grown
+ * Warning: do not insert elements already present
+ */
+int avl_insert(avl_tree* t, avl* a) {
+ /* initialize */
+ a->left = 0;
+ a->right = 0;
+ a->balance = 0;
+ /* insert into an empty tree */
+ if (!t->root) {
+ t->root = a;
+ return 1;
+ }
+
+ if (t->compar(t->root, a) > 0) {
+ /* insert into the left subtree */
+ if (t->root->left) {
+ avl_tree left_subtree;
+ left_subtree.root = t->root->left;
+ left_subtree.compar = t->compar;
+ if (avl_insert(&left_subtree, a)) {
+ switch (t->root->balance--) {
+ case 1:
+ return 0;
+ case 0:
+ return 1;
+ }
+ if (t->root->left->balance < 0) {
+ avl_swr(&(t->root));
+ t->root->balance = 0;
+ t->root->right->balance = 0;
+ } else {
+ avl_swl(&(t->root->left));
+ avl_swr(&(t->root));
+ avl_nasty(t->root);
+ }
+ } else
+ t->root->left = left_subtree.root;
+ return 0;
+ } else {
+ t->root->left = a;
+ if (t->root->balance--)
+ return 0;
+ return 1;
+ }
+ } else {
+ /* insert into the right subtree */
+ if (t->root->right) {
+ avl_tree right_subtree;
+ right_subtree.root = t->root->right;
+ right_subtree.compar = t->compar;
+ if (avl_insert(&right_subtree, a)) {
+ switch (t->root->balance++) {
+ case -1:
+ return 0;
+ case 0:
+ return 1;
+ }
+ if (t->root->right->balance > 0) {
+ avl_swl(&(t->root));
+ t->root->balance = 0;
+ t->root->left->balance = 0;
+ } else {
+ avl_swr(&(t->root->right));
+ avl_swl(&(t->root));
+ avl_nasty(t->root);
+ }
+ } else
+ t->root->right = right_subtree.root;
+ return 0;
+ } else {
+ t->root->right = a;
+ if (t->root->balance++)
+ return 0;
+ return 1;
+ }
+ }
+}
+
+/* Remove an element a from the AVL tree t
+ * returns -1 if the depth of the tree has shrunk
+ * Warning: if the element is not present in the tree,
+ * returns 0 as if it had been removed succesfully.
+ */
+int avl_remove(avl_tree* t, avl* a) {
+ int b;
+ if (t->root == a)
+ return avl_removeroot(t);
+ b = t->compar(t->root, a);
+ if (b >= 0) {
+ /* remove from the left subtree */
+ int ch;
+ avl_tree left_subtree;
+ if ((left_subtree.root = t->root->left)) {
+ left_subtree.compar = t->compar;
+ ch = avl_remove(&left_subtree, a);
+ t->root->left = left_subtree.root;
+ if (ch) {
+ switch (t->root->balance++) {
+ case -1:
+ return -1;
+ case 0:
+ return 0;
+ }
+ switch (t->root->right->balance) {
+ case 0:
+ avl_swl(&(t->root));
+ t->root->balance = -1;
+ t->root->left->balance = 1;
+ return 0;
+ case 1:
+ avl_swl(&(t->root));
+ t->root->balance = 0;
+ t->root->left->balance = 0;
+ return -1;
+ }
+ avl_swr(&(t->root->right));
+ avl_swl(&(t->root));
+ avl_nasty(t->root);
+ return -1;
+ }
+ }
+ }
+ if (b <= 0) {
+ /* remove from the right subtree */
+ int ch;
+ avl_tree right_subtree;
+ if ((right_subtree.root = t->root->right)) {
+ right_subtree.compar = t->compar;
+ ch = avl_remove(&right_subtree, a);
+ t->root->right = right_subtree.root;
+ if (ch) {
+ switch (t->root->balance--) {
+ case 1:
+ return -1;
+ case 0:
+ return 0;
+ }
+ switch (t->root->left->balance) {
+ case 0:
+ avl_swr(&(t->root));
+ t->root->balance = 1;
+ t->root->right->balance = -1;
+ return 0;
+ case -1:
+ avl_swr(&(t->root));
+ t->root->balance = 0;
+ t->root->right->balance = 0;
+ return -1;
+ }
+ avl_swl(&(t->root->left));
+ avl_swr(&(t->root));
+ avl_nasty(t->root);
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+/* Remove the root of the AVL tree t
+ * Warning: dumps core if t is empty
+ */
+int avl_removeroot(avl_tree* t) {
+ int ch;
+ avl* a;
+ if (!t->root->left) {
+ if (!t->root->right) {
+ t->root = 0;
+ return -1;
+ }
+ t->root = t->root->right;
+ return -1;
+ }
+ if (!t->root->right) {
+ t->root = t->root->left;
+ return -1;
+ }
+ if (t->root->balance < 0) {
+ /* remove from the left subtree */
+ a = t->root->left;
+ while (a->right)
+ a = a->right;
+ } else {
+ /* remove from the right subtree */
+ a = t->root->right;
+ while (a->left)
+ a = a->left;
+ }
+ ch = avl_remove(t, a);
+ a->left = t->root->left;
+ a->right = t->root->right;
+ a->balance = t->root->balance;
+ t->root = a;
+ if (a->balance == 0)
+ return ch;
+ return 0;
+}
+
+/* Iterate through elements in t from a range between a and b (inclusive)
+ * for each element calls iter(a) until it returns 0
+ * returns the last value returned by iterator or 0 if there were no calls
+ * Warning: a<=b must hold
+ */
+int avl_range(avl_tree* t, avl* a, avl* b, int (*iter)(avl* a), avl** ret) {
+ int x, c = 0;
+ if (!t->root)
+ return 0;
+ x = t->compar(t->root, a);
+ if (a != b) {
+ if (x < 0) {
+ x = t->compar(t->root, b);
+ if (x > 0)
+ x = 0;
+ }
+ }
+ if (x >= 0) {
+ /* search in the left subtree */
+ avl_tree left_subtree;
+ if ((left_subtree.root = t->root->left)) {
+ left_subtree.compar = t->compar;
+ if (!(c = avl_range(&left_subtree, a, b, iter, ret)))
+ if (x > 0)
+ return 0;
+ }
+ }
+ if (x == 0) {
+ if (!(c = iter(t->root))) {
+ if (ret)
+ *ret = t->root;
+ return 0;
+ }
+ }
+ if (x <= 0) {
+ /* search in the right subtree */
+ avl_tree right_subtree;
+ if ((right_subtree.root = t->root->right)) {
+ right_subtree.compar = t->compar;
+ if (!(c = avl_range(&right_subtree, a, b, iter, ret)))
+ if (x < 0)
+ return 0;
+ }
+ }
+ return c;
+}
+
+/* Iterate through elements in t equal to a
+ * for each element calls iter(a) until it returns 0
+ * returns the last value returned by iterator or 0 if there were no calls
+ */
+int avl_search(avl_tree* t, avl* a, int (*iter)(avl* a), avl** ret) {
+ return avl_range(t, a, a, iter, ret);
+}
--- /dev/null
+/*
+ * ANSI C Library for maintainance of AVL Balanced Trees
+ *
+ * ref.:
+ * G. M. Adelson-Velskij & E. M. Landis
+ * Doklady Akad. Nauk SSSR 146 (1962), 263-266
+ *
+ * see also:
+ * D. E. Knuth: The Art of Computer Programming Vol.3 (Sorting and Searching)
+ *
+ * (C) 2000 Daniel Nagy, Budapest University of Technology and Economics
+ * Released under GNU General Public License (GPL) version 2
+ *
+ */
+
+#ifndef _AVL_H
+#define _AVL_H 1
+
+/* Data structures */
+
+/* One element of the AVL tree */
+typedef struct avl {
+ struct avl* left;
+ struct avl* right;
+ signed char balance;
+} avl;
+
+/* An AVL tree */
+typedef struct avl_tree {
+ avl* root;
+ int (*compar)(void* a, void* b);
+} avl_tree;
+
+/* Public methods */
+
+/* Insert element a into the AVL tree t
+ * returns 1 if the depth of the tree has grown
+ * Warning: do not insert elements already present
+ */
+int avl_insert(avl_tree* t, avl* a);
+
+/* Remove an element a from the AVL tree t
+ * returns -1 if the depth of the tree has shrunk
+ * Warning: if the element is not present in the tree,
+ * returns 0 as if it had been removed succesfully.
+ */
+int avl_remove(avl_tree* t, avl* a);
+
+/* Remove the root of the AVL tree t
+ * Warning: dumps core if t is empty
+ */
+int avl_removeroot(avl_tree* t);
+
+/* Iterate through elements in t from a range between a and b (inclusive)
+ * for each element calls iter(a) until it returns 0
+ * returns the last value returned by iterator or 0 if there were no calls
+ * Warning: a<=b must hold
+ */
+int avl_range(avl_tree* t, avl* a, avl* b, int (*iter)(avl* a), avl** ret);
+
+/* Iterate through elements in t equal to a
+ * for each element calls iter(a) until it returns 0
+ * returns the last value returned by iterator or 0 if there were no calls
+ */
+int avl_search(avl_tree* t, avl* a, int (*iter)(avl* a), avl** ret);
+
+#endif /* avl.h */
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
-#include <malloc.h>
#include "log.h"
#include "common.h"
-#include "web_client.h"
// http://stackoverflow.com/questions/7666509/hash-function-for-string
unsigned long simple_hash(const char *name)
return ret;
}
-void log_allocations(void)
-{
- static int mem = 0;
-
- struct mallinfo mi;
-
- mi = mallinfo();
- if(mi.uordblks > mem) {
- int clients = 0;
- struct web_client *w;
- for(w = web_clients; w ; w = w->next) clients++;
-
- info("Allocated memory increased from %d to %d (increased by %d bytes). There are %d web clients connected.", mem, mi.uordblks, mi.uordblks - mem, clients);
- mem = mi.uordblks;
- }
-}
-
int fd_is_valid(int fd) {
return fcntl(fd, F_GETFD) != -1 || errno != EBADF;
}
extern void *mymmap(const char *filename, unsigned long size, int flags);
extern int savememory(const char *filename, void *mem, unsigned long size);
-extern void log_allocations(void);
-
extern int fd_is_valid(int fd);
#endif /* NETDATA_COMMON_H */
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
+#include <inttypes.h>
+#include "avl.h"
#include "common.h"
#include "config.h"
#include "log.h"
pthread_rwlock_t config_rwlock = PTHREAD_RWLOCK_INITIALIZER;
+// ----------------------------------------------------------------------------
+// definitions
+
+#define CONFIG_VALUE_LOADED 0x01 // has been loaded from the config
+#define CONFIG_VALUE_USED 0x02 // has been accessed from the program
+#define CONFIG_VALUE_CHANGED 0x04 // has been changed from the loaded value
+#define CONFIG_VALUE_CHECKED 0x08 // has been checked if the value is different from the default
+
struct config_value {
- char name[CONFIG_MAX_NAME + 1];
- char value[CONFIG_MAX_VALUE + 1];
+ avl avl;
unsigned long hash; // a simple hash to speed up searching
// we first compare hashes, and only if the hashes are equal we do string comparisons
- int loaded; // loaded from the user config
- int used; // has been accessed from the program
- int changed; // changed from the internal default
+ char name[CONFIG_MAX_NAME + 1];
+ char value[CONFIG_MAX_VALUE + 1];
+
+ uint8_t flags;
struct config_value *next;
};
struct config {
- char name[CONFIG_MAX_NAME + 1];
+ avl avl;
unsigned long hash; // a simple hash to speed up searching
// we first compare hashes, and only if the hashes are equal we do string comparisons
+ char name[CONFIG_MAX_NAME + 1];
+
struct config_value *values;
+ avl_tree values_index;
struct config *next;
} *config_root = NULL;
+
+// ----------------------------------------------------------------------------
+// config value
+
+static int config_value_iterator(avl *a) { if(a) {}; return 0; }
+
+static int config_value_compare(void* a, void* b) {
+ if(((struct config_value *)a)->hash < ((struct config_value *)b)->hash) return -1;
+ else if(((struct config_value *)a)->hash > ((struct config_value *)b)->hash) return 1;
+ else return strcmp(((struct config_value *)a)->name, ((struct config_value *)b)->name);
+}
+
+#define config_value_index_add(co, cv) avl_insert(&((co)->values_index), (avl *)(cv))
+#define config_value_index_del(co, cv) avl_remove(&((co)->values_index), (avl *)(cv))
+
+static struct config_value *config_value_index_find(struct config *co, const char *name, unsigned long hash) {
+ struct config_value *result = NULL, tmp;
+ tmp.hash = (hash)?hash:simple_hash(name);
+ strncpy(tmp.name, name, CONFIG_MAX_NAME);
+ tmp.name[CONFIG_MAX_NAME] = '\0';
+
+ avl_search(&(co->values_index), (avl *)&tmp, config_value_iterator, (avl **)&result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// config
+
+static int config_iterator(avl *a) { if(a) {}; return 0; }
+
+static int config_compare(void* a, void* b) {
+ if(((struct config *)a)->hash < ((struct config *)b)->hash) return -1;
+ else if(((struct config *)a)->hash > ((struct config *)b)->hash) return 1;
+ else return strcmp(((struct config *)a)->name, ((struct config *)b)->name);
+}
+
+avl_tree config_root_index = {
+ NULL,
+ config_compare
+};
+
+#define config_index_add(cfg) avl_insert(&config_root_index, (avl *)(cfg))
+#define config_index_del(cfg) avl_remove(&config_root_index, (avl *)(cfg))
+
+static struct config *config_index_find(const char *name, unsigned long hash) {
+ struct config *result = NULL, tmp;
+ tmp.hash = (hash)?hash:simple_hash(name);
+ strncpy(tmp.name, name, CONFIG_MAX_NAME);
+ tmp.name[CONFIG_MAX_NAME] = '\0';
+
+ avl_search(&config_root_index, (avl *)&tmp, config_iterator, (avl **)&result);
+ return result;
+}
+
struct config_value *config_value_create(struct config *co, const char *name, const char *value)
{
debug(D_CONFIG, "Creating config entry for name '%s', value '%s', in section '%s'.", name, value, co->name);
strncpy(cv->value, value, CONFIG_MAX_VALUE);
cv->hash = simple_hash(cv->name);
+ config_value_index_add(co, cv);
+
// no need for string termination, due to calloc()
struct config_value *cv2 = co->values;
strncpy(co->name, section, CONFIG_MAX_NAME);
co->hash = simple_hash(co->name);
+ co->values_index.compar = config_value_compare;
+
+ config_index_add(co);
// no need for string termination, due to calloc()
struct config *config_find_section(const char *section)
{
- struct config *co;
- unsigned long hash = simple_hash(section);
-
- for(co = config_root; co ; co = co->next)
- if(hash == co->hash)
- if(strcmp(co->name, section) == 0)
- break;
-
- return co;
+ return config_index_find(section, 0);
}
int load_config(char *filename, int overwrite_used)
continue;
}
- struct config_value *cv;
- for(cv = co->values; cv ; cv = cv->next)
- if(strcmp(cv->name, name) == 0) break;
+ struct config_value *cv = config_value_index_find(co, name, 0);
if(!cv) cv = config_value_create(co, name, value);
else {
- if((cv->used && overwrite_used) || !cv->used) {
+ if((cv->flags & CONFIG_VALUE_USED && overwrite_used) || !(cv->flags & CONFIG_VALUE_USED)) {
debug(D_CONFIG, "Overwriting '%s/%s'.", line, co->name, cv->name);
strncpy(cv->value, value, CONFIG_MAX_VALUE);
// termination is already there
else
debug(D_CONFIG, "Ignoring line %d, '%s/%s' is already present and used.", line, co->name, cv->name);
}
- cv->loaded = 1;
+ cv->flags |= CONFIG_VALUE_LOADED;
}
fclose(fp);
struct config *co = config_find_section(section);
if(!co) co = config_create(section);
- unsigned long hash = simple_hash(name);
- for(cv = co->values; cv ; cv = cv->next)
- if(hash == cv->hash)
- if(strcmp(cv->name, name) == 0)
- break;
-
+ cv = config_value_index_find(co, name, 0);
if(!cv) cv = config_value_create(co, name, default_value);
- cv->used = 1;
+ cv->flags |= CONFIG_VALUE_USED;
- if(cv->loaded || cv->changed) {
+ if(cv->flags & CONFIG_VALUE_LOADED || cv->flags & CONFIG_VALUE_CHANGED) {
// this is a loaded value from the config file
// if it is different that the default, mark it
- if(strcmp(cv->value, default_value) != 0) cv->changed = 1;
+ if(!(cv->flags & CONFIG_VALUE_CHECKED)) {
+ if(strcmp(cv->value, default_value) != 0) cv->flags |= CONFIG_VALUE_CHANGED;
+ cv->flags |= CONFIG_VALUE_CHECKED;
+ }
}
else {
// this is not loaded from the config
struct config *co = config_find_section(section);
if(!co) co = config_create(section);
- unsigned long hash = simple_hash(name);
- for(cv = co->values; cv ; cv = cv->next)
- if(hash == cv->hash)
- if(strcmp(cv->name, name) == 0)
- break;
-
+ cv = config_value_index_find(co, name, 0);
if(!cv) cv = config_value_create(co, name, value);
- cv->used = 1;
+ cv->flags |= CONFIG_VALUE_USED;
- if(strcmp(cv->value, value) != 0) cv->changed = 1;
+ if(strcmp(cv->value, value) != 0) cv->flags |= CONFIG_VALUE_CHANGED;
strncpy(cv->value, value, CONFIG_MAX_VALUE);
// termination is already there
int changed = 0;
int count = 0;
for(cv = co->values; cv ; cv = cv->next) {
- used += cv->used;
- changed += cv->changed;
+ used += (cv->flags && CONFIG_VALUE_USED)?1:0;
+ changed += (cv->flags & CONFIG_VALUE_CHANGED)?1:0;
count++;
}
for(cv = co->values; cv ; cv = cv->next) {
- if(used && !cv->used) {
+ if(used && !(cv->flags & CONFIG_VALUE_USED)) {
web_buffer_increase(wb, CONFIG_MAX_NAME + 200);
web_buffer_printf(wb, "\n\t# option '%s' is not used.\n", cv->name);
}
web_buffer_increase(wb, CONFIG_MAX_NAME + CONFIG_MAX_VALUE + 5);
- web_buffer_printf(wb, "\t%s%s = %s\n", (!cv->changed && cv->used)?"# ":"", cv->name, cv->value);
+ web_buffer_printf(wb, "\t%s%s = %s\n", ((!(cv->flags & CONFIG_VALUE_CHANGED)) && (cv->flags & CONFIG_VALUE_USED))?"# ":"", cv->name, cv->value);
}
}
}
signal(SIGINT, SIG_IGN);
kill_childs();
process_childs(0);
- rrd_stats_free_all();
+ rrdset_free_all();
//unlink("/var/run/netdata.pid");
info("NetData exiting. Bye bye...");
exit(1);
else if(strcmp(argv[i], "--unittest") == 0) {
if(unit_test_storage()) exit(1);
exit(0);
- update_every = 1;
+ rrd_update_every = 1;
if(unit_test(1000000, 0)) exit(1);
if(unit_test(1000000, 500000)) exit(1);
if(unit_test(1000000, 100000)) exit(1);
fprintf(stderr, "Cannot understand option '%s'.\n", argv[i]);
fprintf(stderr, "\nUSAGE: %s [-d] [-l LINES_TO_SAVE] [-u UPDATE_TIMER] [-p LISTEN_PORT] [-dl debug log file] [-df debug flags].\n\n", argv[0]);
fprintf(stderr, " -c CONFIG FILE the configuration file to load. Default: %s.\n", CONFIG_DIR "/" CONFIG_FILENAME);
- fprintf(stderr, " -l LINES_TO_SAVE can be from 5 to %d lines in JSON data. Default: %d.\n", HISTORY_MAX, HISTORY);
+ fprintf(stderr, " -l LINES_TO_SAVE can be from 5 to %d lines in JSON data. Default: %d.\n", RRD_HISTORY_ENTRIES_MAX, RRD_DEFAULT_HISTORY_ENTRIES);
fprintf(stderr, " -t UPDATE_TIMER can be from 1 to %d seconds. Default: %d.\n", UPDATE_EVERY_MAX, UPDATE_EVERY);
fprintf(stderr, " -p LISTEN_PORT can be from 1 to %d. Default: %d.\n", 65535, LISTEN_PORT);
fprintf(stderr, " -u USERNAME can be any system username to run as. Default: none.\n");
// --------------------------------------------------------------------
- memory_mode = memory_mode_id(config_get("global", "memory mode", memory_mode_name(memory_mode)));
+ rrd_memory_mode = rrd_memory_mode_id(config_get("global", "memory mode", rrd_memory_mode_name(rrd_memory_mode)));
// --------------------------------------------------------------------
// --------------------------------------------------------------------
- save_history = config_get_number("global", "history", HISTORY);
- if(save_history < 5 || save_history > HISTORY_MAX) {
- fprintf(stderr, "Invalid save lines %d given. Defaulting to %d.\n", save_history, HISTORY);
- save_history = HISTORY;
+ rrd_default_history_entries = config_get_number("global", "history", RRD_DEFAULT_HISTORY_ENTRIES);
+ if(rrd_default_history_entries < 5 || rrd_default_history_entries > RRD_HISTORY_ENTRIES_MAX) {
+ fprintf(stderr, "Invalid save lines %d given. Defaulting to %d.\n", rrd_default_history_entries, RRD_DEFAULT_HISTORY_ENTRIES);
+ rrd_default_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
}
else {
- debug(D_OPTIONS, "save lines set to %d.", save_history);
+ debug(D_OPTIONS, "save lines set to %d.", rrd_default_history_entries);
}
// --------------------------------------------------------------------
- update_every = config_get_number("global", "update every", UPDATE_EVERY);
- if(update_every < 1 || update_every > 600) {
- fprintf(stderr, "Invalid update timer %d given. Defaulting to %d.\n", update_every, UPDATE_EVERY_MAX);
- update_every = UPDATE_EVERY;
+ rrd_update_every = config_get_number("global", "update every", UPDATE_EVERY);
+ if(rrd_update_every < 1 || rrd_update_every > 600) {
+ fprintf(stderr, "Invalid update timer %d given. Defaulting to %d.\n", rrd_update_every, UPDATE_EVERY_MAX);
+ rrd_update_every = UPDATE_EVERY;
}
- else debug(D_OPTIONS, "update timer set to %d.", update_every);
+ else debug(D_OPTIONS, "update timer set to %d.", rrd_update_every);
// --------------------------------------------------------------------
if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0)
error("Cannot set pthread cancel state to ENABLE.");
- unsigned long long usec = 0, susec = update_every * 1000000ULL, loop_usec = 0, total_susec = 0;
+ unsigned long long usec = 0, susec = rrd_update_every * 1000000ULL, loop_usec = 0, total_susec = 0;
struct timeval now, last, loop;
- RRD_STATS *check1, *check2, *check3, *apps_cpu = NULL;
+ RRDSET *check1, *check2, *check3, *apps_cpu = NULL;
- check1 = rrd_stats_create("netdata", "check1", NULL, "netdata", "Caller gives microseconds", "a million !", 99999, update_every, CHART_TYPE_LINE);
- rrd_stats_dimension_add(check1, "absolute", NULL, -1, 1, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(check1, "incremental", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ check1 = rrdset_create("netdata", "check1", NULL, "netdata", "Caller gives microseconds", "a million !", 99999, rrd_update_every, RRDSET_TYPE_LINE);
+ rrddim_add(check1, "absolute", NULL, -1, 1, RRDDIM_ABSOLUTE);
+ rrddim_add(check1, "incremental", NULL, 1, 1 * rrd_update_every, RRDDIM_INCREMENTAL);
- check2 = rrd_stats_create("netdata", "check2", NULL, "netdata", "Netdata calcs microseconds", "a million !", 99999, update_every, CHART_TYPE_LINE);
- rrd_stats_dimension_add(check2, "absolute", NULL, -1, 1, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(check2, "incremental", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ check2 = rrdset_create("netdata", "check2", NULL, "netdata", "Netdata calcs microseconds", "a million !", 99999, rrd_update_every, RRDSET_TYPE_LINE);
+ rrddim_add(check2, "absolute", NULL, -1, 1, RRDDIM_ABSOLUTE);
+ rrddim_add(check2, "incremental", NULL, 1, 1 * rrd_update_every, RRDDIM_INCREMENTAL);
- check3 = rrd_stats_create("netdata", "checkdt", NULL, "netdata", "Clock difference", "microseconds diff", 99999, update_every, CHART_TYPE_LINE);
- rrd_stats_dimension_add(check3, "caller", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(check3, "netdata", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(check3, "apps.plugin", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ check3 = rrdset_create("netdata", "checkdt", NULL, "netdata", "Clock difference", "microseconds diff", 99999, rrd_update_every, RRDSET_TYPE_LINE);
+ rrddim_add(check3, "caller", NULL, 1, 1, RRDDIM_ABSOLUTE);
+ rrddim_add(check3, "netdata", NULL, 1, 1, RRDDIM_ABSOLUTE);
+ rrddim_add(check3, "apps.plugin", NULL, 1, 1, RRDDIM_ABSOLUTE);
gettimeofday(&last, NULL);
while(1) {
usec = loop_usec - susec;
debug(D_PROCNETDEV_LOOP, "CHECK: last loop took %llu usec (worked for %llu, sleeped for %llu).", loop_usec, usec, susec);
- if(usec < (update_every * 1000000ULL / 2ULL)) susec = (update_every * 1000000ULL) - usec;
- else susec = update_every * 1000000ULL / 2ULL;
+ if(usec < (rrd_update_every * 1000000ULL / 2ULL)) susec = (rrd_update_every * 1000000ULL) - usec;
+ else susec = rrd_update_every * 1000000ULL / 2ULL;
// --------------------------------------------------------------------
// Calculate loop time
// --------------------------------------------------------------------
// check chart 1
- if(check1->counter_done) rrd_stats_next_usec(check1, loop_usec);
- rrd_stats_dimension_set(check1, "absolute", 1000000);
- rrd_stats_dimension_set(check1, "incremental", total_susec);
- rrd_stats_done(check1);
+ if(check1->counter_done) rrdset_next_usec(check1, loop_usec);
+ rrddim_set(check1, "absolute", 1000000);
+ rrddim_set(check1, "incremental", total_susec);
+ rrdset_done(check1);
// --------------------------------------------------------------------
// check chart 2
- if(check2->counter_done) rrd_stats_next(check2);
- rrd_stats_dimension_set(check2, "absolute", 1000000);
- rrd_stats_dimension_set(check2, "incremental", total_susec);
- rrd_stats_done(check2);
+ if(check2->counter_done) rrdset_next(check2);
+ rrddim_set(check2, "absolute", 1000000);
+ rrddim_set(check2, "incremental", total_susec);
+ rrdset_done(check2);
// --------------------------------------------------------------------
// check chart 3
- if(!apps_cpu) apps_cpu = rrd_stats_find("apps.cpu");
- if(check3->counter_done) rrd_stats_next_usec(check3, loop_usec);
+ if(!apps_cpu) apps_cpu = rrdset_find("apps.cpu");
+ if(check3->counter_done) rrdset_next_usec(check3, loop_usec);
gettimeofday(&loop, NULL);
- rrd_stats_dimension_set(check3, "caller", (long long)usecdiff(&loop, &check1->last_collected_time));
- rrd_stats_dimension_set(check3, "netdata", (long long)usecdiff(&loop, &check2->last_collected_time));
- if(apps_cpu) rrd_stats_dimension_set(check3, "apps.plugin", (long long)usecdiff(&loop, &apps_cpu->last_collected_time));
- rrd_stats_done(check3);
+ rrddim_set(check3, "caller", (long long)usecdiff(&loop, &check1->last_collected_time));
+ rrddim_set(check3, "netdata", (long long)usecdiff(&loop, &check2->last_collected_time));
+ if(apps_cpu) rrddim_set(check3, "apps.plugin", (long long)usecdiff(&loop, &apps_cpu->last_collected_time));
+ rrdset_done(check3);
}
return NULL;
sleep_ms = CPU_IDLEJITTER_SLEEP_TIME_MS;
}
- RRD_STATS *st = rrd_stats_find("system.idlejitter");
+ RRDSET *st = rrdset_find("system.idlejitter");
if(!st) {
- st = rrd_stats_create("system", "idlejitter", NULL, "cpu", "CPU Idle Jitter", "microseconds lost/s", 9999, update_every, CHART_TYPE_LINE);
- rrd_stats_dimension_add(st, "jitter", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ st = rrdset_create("system", "idlejitter", NULL, "cpu", "CPU Idle Jitter", "microseconds lost/s", 9999, rrd_update_every, RRDSET_TYPE_LINE);
+ rrddim_add(st, "jitter", NULL, 1, 1, RRDDIM_ABSOLUTE);
}
struct timeval before, after;
for(counter = 0; 1 ;counter++) {
unsigned long long usec = 0, susec = 0;
- while(susec < (update_every * 1000000ULL)) {
+ while(susec < (rrd_update_every * 1000000ULL)) {
gettimeofday(&before, NULL);
usleep(sleep_ms * 1000);
}
usec -= (sleep_ms * 1000);
- if(counter) rrd_stats_next_usec(st, susec);
- rrd_stats_dimension_set(st, "jitter", usec);
- rrd_stats_done(st);
+ if(counter) rrdset_next_usec(st, susec);
+ rrddim_set(st, "jitter", usec);
+ rrdset_done(st);
}
return NULL;
struct timeval last, now;
unsigned long long usec = 0, susec = 0;
- RRD_STATS *st = NULL;
+ RRDSET *st = NULL;
gettimeofday(&last, NULL);
usec = usecdiff(&now, &last) - susec;
debug(D_NFACCT_LOOP, "nfacct.plugin: last loop took %llu usec (worked for %llu, sleeped for %llu).", usec + susec, usec, susec);
- if(usec < (update_every * 1000000ULL / 2ULL)) susec = (update_every * 1000000ULL) - usec;
- else susec = update_every * 1000000ULL / 2ULL;
+ if(usec < (rrd_update_every * 1000000ULL / 2ULL)) susec = (rrd_update_every * 1000000ULL) - usec;
+ else susec = rrd_update_every * 1000000ULL / 2ULL;
// --------------------------------------------------------------------
if(nfacct_list && nfacct_list->len) {
int i;
- st = rrd_stats_find_bytype("nfacct", "packets");
+ st = rrdset_find_bytype("nfacct", "packets");
if(!st) {
- st = rrd_stats_create("nfacct", "packets", NULL, "netfilter", "Netfilter Accounting Packets", "packets/s", 1006, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfacct", "packets", NULL, "netfilter", "Netfilter Accounting Packets", "packets/s", 1006, rrd_update_every, RRDSET_TYPE_STACKED);
for(i = 0; i < nfacct_list->len ; i++)
- rrd_stats_dimension_add(st, nfacct_list->data[i].name, NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, nfacct_list->data[i].name, NULL, 1, rrd_update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
for(i = 0; i < nfacct_list->len ; i++) {
- RRD_DIMENSION *rd = rrd_stats_dimension_find(st, nfacct_list->data[i].name);
+ RRDDIM *rd = rrddim_find(st, nfacct_list->data[i].name);
- if(!rd) rd = rrd_stats_dimension_add(st, nfacct_list->data[i].name, NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- if(rd) rrd_stats_dimension_set_by_pointer(st, rd, nfacct_list->data[i].pkts);
+ if(!rd) rd = rrddim_add(st, nfacct_list->data[i].name, NULL, 1, rrd_update_every, RRDDIM_INCREMENTAL);
+ if(rd) rrddim_set_by_pointer(st, rd, nfacct_list->data[i].pkts);
}
- rrd_stats_done(st);
+ rrdset_done(st);
// ----------------------------------------------------------------
- st = rrd_stats_find_bytype("nfacct", "bytes");
+ st = rrdset_find_bytype("nfacct", "bytes");
if(!st) {
- st = rrd_stats_create("nfacct", "bytes", NULL, "netfilter", "Netfilter Accounting Bandwidth", "kilobytes/s", 1007, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfacct", "bytes", NULL, "netfilter", "Netfilter Accounting Bandwidth", "kilobytes/s", 1007, rrd_update_every, RRDSET_TYPE_STACKED);
for(i = 0; i < nfacct_list->len ; i++)
- rrd_stats_dimension_add(st, nfacct_list->data[i].name, NULL, 1, 1000 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, nfacct_list->data[i].name, NULL, 1, 1000 * rrd_update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
for(i = 0; i < nfacct_list->len ; i++) {
- RRD_DIMENSION *rd = rrd_stats_dimension_find(st, nfacct_list->data[i].name);
+ RRDDIM *rd = rrddim_find(st, nfacct_list->data[i].name);
- if(!rd) rd = rrd_stats_dimension_add(st, nfacct_list->data[i].name, NULL, 1, 1000 * update_every, RRD_DIMENSION_INCREMENTAL);
- if(rd) rrd_stats_dimension_set_by_pointer(st, rd, nfacct_list->data[i].bytes);
+ if(!rd) rd = rrddim_add(st, nfacct_list->data[i].name, NULL, 1, 1000 * rrd_update_every, RRDDIM_INCREMENTAL);
+ if(rd) rrddim_set_by_pointer(st, rd, nfacct_list->data[i].bytes);
}
- rrd_stats_done(st);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
struct timeval last, now;
gettimeofday(&last, NULL);
- last.tv_sec -= update_every;
+ last.tv_sec -= rrd_update_every;
// disable (by default) various interface that are not needed
config_get_boolean("plugin:proc:/proc/net/dev", "interface lo", 0);
int vdo_proc_net_rpc_nfsd = !config_get_boolean("plugin:proc", "/proc/net/rpc/nfsd", 1);
int vdo_cpu_netdata = !config_get_boolean("plugin:proc", "netdata server resources", 1);
- RRD_STATS *stcpu = NULL, *stclients = NULL, *streqs = NULL, *stbytes = NULL;
+ RRDSET *stcpu = NULL, *stclients = NULL, *streqs = NULL, *stbytes = NULL;
gettimeofday(&last, NULL);
getrusage(RUSAGE_SELF, &me_last);
if(!vdo_proc_net_dev) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_net_dev().");
- vdo_proc_net_dev = do_proc_net_dev(update_every, usec+susec);
+ vdo_proc_net_dev = do_proc_net_dev(rrd_update_every, usec+susec);
}
if(!vdo_proc_diskstats) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_diskstats().");
- vdo_proc_diskstats = do_proc_diskstats(update_every, usec+susec);
+ vdo_proc_diskstats = do_proc_diskstats(rrd_update_every, usec+susec);
}
if(!vdo_proc_net_snmp) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_net_snmp().");
- vdo_proc_net_snmp = do_proc_net_snmp(update_every, usec+susec);
+ vdo_proc_net_snmp = do_proc_net_snmp(rrd_update_every, usec+susec);
}
if(!vdo_proc_net_netstat) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_net_netstat().");
- vdo_proc_net_netstat = do_proc_net_netstat(update_every, usec+susec);
+ vdo_proc_net_netstat = do_proc_net_netstat(rrd_update_every, usec+susec);
}
if(!vdo_proc_net_stat_conntrack) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_net_stat_conntrack().");
- vdo_proc_net_stat_conntrack = do_proc_net_stat_conntrack(update_every, usec+susec);
+ vdo_proc_net_stat_conntrack = do_proc_net_stat_conntrack(rrd_update_every, usec+susec);
}
if(!vdo_proc_net_ip_vs_stats) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling vdo_proc_net_ip_vs_stats().");
- vdo_proc_net_ip_vs_stats = do_proc_net_ip_vs_stats(update_every, usec+susec);
+ vdo_proc_net_ip_vs_stats = do_proc_net_ip_vs_stats(rrd_update_every, usec+susec);
}
if(!vdo_proc_stat) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_stat().");
- vdo_proc_stat = do_proc_stat(update_every, usec+susec);
+ vdo_proc_stat = do_proc_stat(rrd_update_every, usec+susec);
}
if(!vdo_proc_meminfo) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling vdo_proc_meminfo().");
- vdo_proc_meminfo = do_proc_meminfo(update_every, usec+susec);
+ vdo_proc_meminfo = do_proc_meminfo(rrd_update_every, usec+susec);
}
if(!vdo_proc_vmstat) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling vdo_proc_vmstat().");
- vdo_proc_vmstat = do_proc_vmstat(update_every, usec+susec);
+ vdo_proc_vmstat = do_proc_vmstat(rrd_update_every, usec+susec);
}
if(!vdo_proc_net_rpc_nfsd) {
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: calling do_proc_net_rpc_nfsd().");
- vdo_proc_net_rpc_nfsd = do_proc_net_rpc_nfsd(update_every, usec+susec);
+ vdo_proc_net_rpc_nfsd = do_proc_net_rpc_nfsd(rrd_update_every, usec+susec);
}
// END -- the job is done
usec = usecdiff(&now, &last) - susec;
debug(D_PROCNETDEV_LOOP, "PROCNETDEV: last loop took %llu usec (worked for %llu, sleeped for %llu).", usec + susec, usec, susec);
- if(usec < (update_every * 1000000ULL / 2ULL)) susec = (update_every * 1000000ULL) - usec;
- else susec = update_every * 1000000ULL / 2ULL;
+ if(usec < (rrd_update_every * 1000000ULL / 2ULL)) susec = (rrd_update_every * 1000000ULL) - usec;
+ else susec = rrd_update_every * 1000000ULL / 2ULL;
// --------------------------------------------------------------------
unsigned long long cpuuser = me.ru_utime.tv_sec * 1000000ULL + me.ru_utime.tv_usec;
unsigned long long cpusyst = me.ru_stime.tv_sec * 1000000ULL + me.ru_stime.tv_usec;
- if(!stcpu) stcpu = rrd_stats_find("netdata.server_cpu");
+ if(!stcpu) stcpu = rrdset_find("netdata.server_cpu");
if(!stcpu) {
- stcpu = rrd_stats_create("netdata", "server_cpu", NULL, "netdata", "NetData CPU usage", "milliseconds/s", 9999, update_every, CHART_TYPE_STACKED);
+ stcpu = rrdset_create("netdata", "server_cpu", NULL, "netdata", "NetData CPU usage", "milliseconds/s", 9999, rrd_update_every, RRDSET_TYPE_STACKED);
- rrd_stats_dimension_add(stcpu, "user", NULL, 1, 1000 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(stcpu, "system", NULL, 1, 1000 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(stcpu, "user", NULL, 1, 1000 * rrd_update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(stcpu, "system", NULL, 1, 1000 * rrd_update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(stcpu);
+ else rrdset_next(stcpu);
- rrd_stats_dimension_set(stcpu, "user", cpuuser);
- rrd_stats_dimension_set(stcpu, "system", cpusyst);
- rrd_stats_done(stcpu);
+ rrddim_set(stcpu, "user", cpuuser);
+ rrddim_set(stcpu, "system", cpusyst);
+ rrdset_done(stcpu);
bcopy(&me, &me_last, sizeof(struct rusage));
// ----------------------------------------------------------------
- if(!stclients) stclients = rrd_stats_find("netdata.clients");
+ if(!stclients) stclients = rrdset_find("netdata.clients");
if(!stclients) {
- stclients = rrd_stats_create("netdata", "clients", NULL, "netdata", "NetData Web Clients", "connected clients", 11000, update_every, CHART_TYPE_LINE);
+ stclients = rrdset_create("netdata", "clients", NULL, "netdata", "NetData Web Clients", "connected clients", 11000, rrd_update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(stclients, "clients", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(stclients, "clients", NULL, 1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(stclients);
+ else rrdset_next(stclients);
- rrd_stats_dimension_set(stclients, "clients", global_statistics.connected_clients);
- rrd_stats_done(stclients);
+ rrddim_set(stclients, "clients", global_statistics.connected_clients);
+ rrdset_done(stclients);
// ----------------------------------------------------------------
- if(!streqs) streqs = rrd_stats_find("netdata.requests");
+ if(!streqs) streqs = rrdset_find("netdata.requests");
if(!streqs) {
- streqs = rrd_stats_create("netdata", "requests", NULL, "netdata", "NetData Web Requests", "requests/s", 12000, update_every, CHART_TYPE_LINE);
+ streqs = rrdset_create("netdata", "requests", NULL, "netdata", "NetData Web Requests", "requests/s", 12000, rrd_update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(streqs, "requests", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(streqs, "requests", NULL, 1, 1 * rrd_update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(streqs);
+ else rrdset_next(streqs);
- rrd_stats_dimension_set(streqs, "requests", global_statistics.web_requests);
- rrd_stats_done(streqs);
+ rrddim_set(streqs, "requests", global_statistics.web_requests);
+ rrdset_done(streqs);
// ----------------------------------------------------------------
- if(!stbytes) stbytes = rrd_stats_find("netdata.net");
+ if(!stbytes) stbytes = rrdset_find("netdata.net");
if(!stbytes) {
- stbytes = rrd_stats_create("netdata", "net", NULL, "netdata", "NetData Network Traffic", "kilobits/s", 13000, update_every, CHART_TYPE_AREA);
+ stbytes = rrdset_create("netdata", "net", NULL, "netdata", "NetData Network Traffic", "kilobits/s", 13000, rrd_update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(stbytes, "in", NULL, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(stbytes, "out", NULL, -8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(stbytes, "in", NULL, 8, 1024 * rrd_update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(stbytes, "out", NULL, -8, 1024 * rrd_update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(stbytes);
+ else rrdset_next(stbytes);
- rrd_stats_dimension_set(stbytes, "in", global_statistics.bytes_received);
- rrd_stats_dimension_set(stbytes, "out", global_statistics.bytes_sent);
- rrd_stats_done(stbytes);
+ rrddim_set(stbytes, "in", global_statistics.bytes_received);
+ rrddim_set(stbytes, "out", global_statistics.bytes_sent);
+ rrdset_done(stbytes);
}
usleep(susec);
#define TC_LINE_MAX 1024
struct tc_class {
- char id[RRD_STATS_NAME_MAX + 1];
- char name[RRD_STATS_NAME_MAX + 1];
+ char id[RRD_ID_LENGTH_MAX + 1];
+ char name[RRD_ID_LENGTH_MAX + 1];
- char leafid[RRD_STATS_NAME_MAX + 1];
- char parentid[RRD_STATS_NAME_MAX + 1];
+ char leafid[RRD_ID_LENGTH_MAX + 1];
+ char parentid[RRD_ID_LENGTH_MAX + 1];
int hasparent;
int isleaf;
};
struct tc_device {
- char id[RRD_STATS_NAME_MAX + 1];
- char name[RRD_STATS_NAME_MAX + 1];
- char family[RRD_STATS_NAME_MAX + 1];
+ char id[RRD_ID_LENGTH_MAX + 1];
+ char name[RRD_ID_LENGTH_MAX + 1];
+ char family[RRD_ID_LENGTH_MAX + 1];
struct tc_class *classes;
};
char var_name[4096 + 1];
snprintf(var_name, 4096, "qos for %s", d->id);
if(config_get_boolean("plugin:tc", var_name, enable_new_interfaces)) {
- RRD_STATS *st = rrd_stats_find_bytype(RRD_TYPE_TC, d->id);
+ RRDSET *st = rrdset_find_bytype(RRD_TYPE_TC, d->id);
if(!st) {
debug(D_TC_LOOP, "TC: Committing new TC device '%s'", d->name);
- st = rrd_stats_create(RRD_TYPE_TC, d->id, d->name, d->family, "Class Usage", "kilobits/s", 1000, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create(RRD_TYPE_TC, d->id, d->name, d->family, "Class Usage", "kilobits/s", 1000, rrd_update_every, RRDSET_TYPE_STACKED);
for ( c = d->classes ; c ; c = c->next) {
if(c->isleaf && c->hasparent)
- rrd_stats_dimension_add(st, c->id, c->name, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, c->id, c->name, 8, 1024 * rrd_update_every, RRDDIM_INCREMENTAL);
}
}
else {
- rrd_stats_next_plugins(st);
+ rrdset_next_plugins(st);
- if(strcmp(d->id, d->name) != 0) rrd_stats_set_name(st, d->name);
+ if(strcmp(d->id, d->name) != 0) rrdset_set_name(st, d->name);
}
for ( c = d->classes ; c ; c = c->next) {
if(c->isleaf && c->hasparent) {
- if(rrd_stats_dimension_set(st, c->id, c->bytes) != 0) {
+ if(rrddim_set(st, c->id, c->bytes) != 0) {
// new class, we have to add it
- rrd_stats_dimension_add(st, c->id, c->name, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_set(st, c->id, c->bytes);
+ rrddim_add(st, c->id, c->name, 8, 1024 * rrd_update_every, RRDDIM_INCREMENTAL);
+ rrddim_set(st, c->id, c->bytes);
}
// if it has a name, different to the id
if(strcmp(c->id, c->name) != 0) {
// update the rrd dimension with the new name
- RRD_DIMENSION *rd;
+ RRDDIM *rd;
for(rd = st->dimensions ; rd ; rd = rd->next) {
- if(strcmp(rd->id, c->id) == 0) { rrd_stats_dimension_set_name(st, rd, c->name); break; }
+ if(strcmp(rd->id, c->id) == 0) { rrddim_set_name(st, rd, c->name); break; }
}
}
}
}
- rrd_stats_done(st);
+ rrdset_done(st);
}
}
struct tc_class *c;
for ( c = d->classes ; c ; c = c->next) {
if(strcmp(c->id, id) == 0) {
- strncpy(c->name, name, RRD_STATS_NAME_MAX);
+ strncpy(c->name, name, RRD_ID_LENGTH_MAX);
// no need for null termination - it is already null
break;
}
void tc_device_set_device_name(struct tc_device *d, char *name)
{
- strncpy(d->name, name, RRD_STATS_NAME_MAX);
+ strncpy(d->name, name, RRD_ID_LENGTH_MAX);
// no need for null termination - it is already null
}
void tc_device_set_device_family(struct tc_device *d, char *name)
{
- strncpy(d->family, name, RRD_STATS_NAME_MAX);
+ strncpy(d->family, name, RRD_ID_LENGTH_MAX);
// no need for null termination - it is already null
}
return NULL;
}
- strncpy(d->id, name, RRD_STATS_NAME_MAX);
+ strncpy(d->id, name, RRD_ID_LENGTH_MAX);
strcpy(d->name, d->id);
strcpy(d->family, d->id);
c->next = n->classes;
n->classes = c;
- strncpy(c->id, id, RRD_STATS_NAME_MAX);
+ strncpy(c->id, id, RRD_ID_LENGTH_MAX);
strcpy(c->name, c->id);
- if(parentid) strncpy(c->parentid, parentid, RRD_STATS_NAME_MAX);
- if(leafid) strncpy(c->leafid, leafid, RRD_STATS_NAME_MAX);
+ if(parentid) strncpy(c->parentid, parentid, RRD_ID_LENGTH_MAX);
+ if(leafid) strncpy(c->leafid, leafid, RRD_ID_LENGTH_MAX);
// no need for null termination on the strings, because of calloc()
struct tc_device *device = NULL;
struct tc_class *class = NULL;
- snprintf(buffer, TC_LINE_MAX, "exec %s %d", config_get("plugin:tc", "script to run to get tc values", PLUGINS_DIR "/tc-qos-helper.sh"), update_every);
+ snprintf(buffer, TC_LINE_MAX, "exec %s %d", config_get("plugin:tc", "script to run to get tc values", PLUGINS_DIR "/tc-qos-helper.sh"), rrd_update_every);
debug(D_TC_LOOP, "executing '%s'", buffer);
// fp = popen(buffer, "r");
fp = mypopen(buffer, &tc_child_pid);
class = NULL;
}
- sleep(update_every);
+ sleep(rrd_update_every);
}
return NULL;
ifndef BIN_DIR\r
-BIN_DIR = "$(PWD)"\r
+BIN_DIR = "."\r
endif\r
\r
ifndef CONFIG_DIR\r
\r
COMMON_FLAGS = BIN_DIR='$(BIN_DIR)' CONFIG_DIR='$(CONFIG_DIR)' LOG_DIR='$(LOG_DIR)' PLUGINS_DIR='$(PLUGINS_DIR)'\r
\r
-CC = gcc\r
+CC := gcc\r
+libs :=\r
\r
ifdef debug\r
COMMON_FLAGS += debug=1\r
-CFLAGS = -Wall -Wextra -ggdb -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)'\r
+# CFLAGS = -Wall -Wextra -ggdb -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)' -fsanitize=address -fno-omit-frame-pointer\r
+CFLAGS := -Wall -Wextra -O -g -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)' -fsanitize=address -fno-omit-frame-pointer\r
+#libs += -ltsan -lpie\r
else\r
-CFLAGS = -Wall -Wextra -O3 -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)'\r
+CFLAGS := -Wall -Wextra -O3 -DBIN_DIR='$(BIN_DIR)' -DCONFIG_DIR='$(CONFIG_DIR)' -DLOG_DIR='$(LOG_DIR)' -DPLUGINS_DIR='$(PLUGINS_DIR)' -fomit-frame-pointer\r
endif\r
\r
all: options plugins\r
plugins: apps.plugin\r
\r
apps.plugin: apps_plugin.c\r
- @echo " $(CC) $@"\r
- @$(CC) $(CFLAGS) -o $@ apps_plugin.c\r
+ $(CC) $(CFLAGS) -o $@ apps_plugin.c ../avl.o ../common.o ../log.o ../procfile.o $(libs)\r
\r
clean:\r
-rm -f *.o apps.plugin core\r
#include <dirent.h>
#include <arpa/inet.h>
+#include "../common.h"
+#include "../log.h"
+#include "../avl.h"
+#include "../procfile.h"
+
#define MAX_COMPARE_NAME 15
#define MAX_NAME 100
// ----------------------------------------------------------------------------
// helper functions
-unsigned long long usecdiff(struct timeval *now, struct timeval *last) {
- return ((((now->tv_sec * 1000000ULL) + now->tv_usec) - ((last->tv_sec * 1000000ULL) + last->tv_usec)));
-}
-
-char *trim(char *s)
-{
- // skip leading spaces
- while(*s && isspace(*s)) s++;
- if(!*s) return NULL;
-
- // skip tailing spaces
- int c = strlen(s) - 1;
- while(c >= 0 && isspace(s[c])) {
- s[c] = '\0';
- c--;
- }
- if(c < 0) return NULL;
- if(!*s) return NULL;
- return s;
-}
-
-unsigned long simple_hash(const char *name)
-{
- int i, len = strlen(name);
- unsigned long hash = 0;
-
- for(i = 0; i < len ;i++) hash += (i * name[i]) + i + name[i];
+long get_processors(void) {
+ int processors = 0;
- return hash;
-}
+ procfile *ff = procfile_open("/proc/stat", O_RDONLY);
+ if(!ff) return 1;
-long get_processors(void)
-{
- char buffer[1025], *s;
- int processors = 0;
+ ff = procfile_readall(ff);
+ if(!ff) {
+ procfile_close(ff);
+ return 1;
+ }
- FILE *fp = fopen("/proc/stat", "r");
- if(!fp) return 1;
+ unsigned int i;
+ for(i = 0; i < procfile_lines(ff); i++) {
+ if(!procfile_linewords(ff, i)) continue;
- while((s = fgets(buffer, 1024, fp))) {
- if(strncmp(buffer, "cpu", 3) == 0) processors++;
+ if(strncmp(procfile_lineword(ff, i, 0), "cpu", 3) == 0) processors++;
}
- fclose(fp);
processors--;
if(processors < 1) processors = 1;
+
+ procfile_close(ff);
return processors;
}
-long get_pid_max(void)
-{
- char buffer[1025], *s;
+long get_pid_max(void) {
long mpid = 32768;
- FILE *fp = fopen("/proc/sys/kernel/pid_max", "r");
- if(!fp) return 1;
+ procfile *ff = procfile_open("/proc/sys/kernel/pid_max", O_RDONLY);
+ if(!ff) return mpid;
- s = fgets(buffer, 1024, fp);
- if(s) mpid = atol(buffer);
- fclose(fp);
- if(mpid < 32768) mpid = 32768;
+ ff = procfile_readall(ff);
+ if(!ff) {
+ procfile_close(ff);
+ return mpid;
+ }
+
+ mpid = atol(procfile_lineword(ff, 0, 0));
+ if(mpid) mpid = 32768;
+
+ procfile_close(ff);
return mpid;
}
hz = (sizeof(long)==sizeof(int) || htons(999)==999) ? 100UL : 1024UL;
#endif
- fprintf(stderr, "apps.plugin: ERROR: unknown HZ value. Assuming %llu.\n", hz);
+ error("apps.plugin: ERROR: unknown HZ value. Assuming %llu.", hz);
return hz;
}
w = calloc(sizeof(struct target), 1);
if(!w) {
- fprintf(stderr, "apps.plugin: cannot allocate %lu bytes of memory\n", (unsigned long)sizeof(struct target));
+ error("apps.plugin: cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct target));
return NULL;
}
if(debug) fprintf(stderr, "apps.plugin: process groups file: '%s'\n", filename);
FILE *fp = fopen(filename, "r");
if(!fp) {
- fprintf(stderr, "apps.plugin: ERROR: cannot open file '%s' (%s)\n", filename, strerror(errno));
+ error("apps.plugin: ERROR: cannot open file '%s' (%s)", filename, strerror(errno));
return 1;
}
}
if(w) strncpy(w->name, t, MAX_NAME);
- if(!count) fprintf(stderr, "apps.plugin: ERROR: the line %ld on file '%s', for group '%s' does not state any process names.\n", line, filename, t);
+ if(!count) error("apps.plugin: ERROR: the line %ld on file '%s', for group '%s' does not state any process names.", line, filename, t);
}
fclose(fp);
all_pids[pid] = calloc(sizeof(struct pid_stat), 1);
if(!all_pids[pid]) {
- fprintf(stderr, "apps.plugin: ERROR: Cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct pid_stat));
+ error("apps.plugin: ERROR: Cannot allocate %lu bytes of memory", (unsigned long)sizeof(struct pid_stat));
return NULL;
}
all_pids[pid]->fds = calloc(sizeof(int), 100);
if(!all_pids[pid]->fds)
- fprintf(stderr, "apps.plugin: ERROR: Cannot allocate %ld bytes of memory\n", (unsigned long)(sizeof(int) * 100));
+ error("apps.plugin: ERROR: Cannot allocate %ld bytes of memory", (unsigned long)(sizeof(int) * 100));
else all_pids[pid]->fds_size = 100;
if(root) root->prev = all_pids[pid];
// this is used to keep a global list of all open files of the system
// it is needed in order to figure out the unique files a process tree has open
+#define FILE_DESCRIPTORS_INCREASE_STEP 100
+
struct file_descriptor {
+ avl avl;
+ unsigned long magic;
unsigned long hash;
- char *name;
+ const char *name;
int type;
long count;
+ long pos;
} *all_files = NULL;
int all_files_len = 0;
int all_files_size = 0;
+int file_descriptor_compare(void* a, void* b) {
+ if(((struct file_descriptor *)a)->magic != 0x0BADCAFE || ((struct file_descriptor *)b)->magic != 0x0BADCAFE)
+ error("Corrupted index data detected. Please report this.");
+
+ if(((struct file_descriptor *)a)->hash < ((struct file_descriptor *)b)->hash)
+ return -1;
+ else if(((struct file_descriptor *)a)->hash > ((struct file_descriptor *)b)->hash)
+ return 1;
+ else return strcmp(((struct file_descriptor *)a)->name, ((struct file_descriptor *)b)->name);
+}
+int file_descriptor_iterator(avl *a) { if(a) {}; return 0; }
+
+avl_tree all_files_index = {
+ NULL,
+ file_descriptor_compare
+};
+
+static struct file_descriptor *file_descriptor_find(const char *name, unsigned long hash) {
+ struct file_descriptor *result = NULL, tmp;
+ tmp.hash = (hash)?hash:simple_hash(name);
+ tmp.name = name;
+ tmp.count = 0;
+ tmp.pos = 0;
+ tmp.magic = 0x0BADCAFE;
+
+ avl_search(&all_files_index, (avl *)&tmp, file_descriptor_iterator, (avl **)&result);
+ return result;
+}
+
+#define file_descriptor_add(fd) avl_insert(&all_files_index, (avl *)(fd))
+#define file_descriptor_remove(fd) avl_remove(&all_files_index, (avl *)(fd))
+
#define FILETYPE_OTHER 0
#define FILETYPE_FILE 1
#define FILETYPE_PIPE 2
void file_descriptor_not_used(int id)
{
- if(id > 0 && id < all_files_len) {
- if(all_files[id].count > 0)
+ if(id > 0 && id < all_files_size) {
+ if(all_files[id].magic != 0x0BADCAFE) {
+ error("Ignoring request to remove empty file id %d.", id);
+ return;
+ }
+
+ if(all_files[id].count > 0) {
all_files[id].count--;
+
+ if(!all_files[id].count) {
+ file_descriptor_remove(&all_files[id]);
+ all_files[id].magic = 0x00000000;
+ all_files_len--;
+ }
+ }
else
- fprintf(stderr, "apps.plugin: ERROR: request to decrease counter of fd %d (%s), while the use counter is 0\n", id, all_files[id].name);
+ error("apps.plugin: ERROR: request to decrease counter of fd %d (%s), while the use counter is 0", id, all_files[id].name);
}
- else fprintf(stderr, "apps.plugin: ERROR: request to decrease counter of fd %d, which is outside the array size (1 to %d)\n", id, all_files_len);
+ else error("apps.plugin: ERROR: request to decrease counter of fd %d, which is outside the array size (1 to %d)", id, all_files_size);
}
unsigned long file_descriptor_find_or_add(const char *name)
{
- int type = FILETYPE_OTHER;
+ static int last_pos = 0;
+ unsigned long hash = simple_hash(name);
+ if(debug) fprintf(stderr, "apps.plugin: adding or finding name '%s' with hash %lu\n", name, hash);
+
+ struct file_descriptor *fd = file_descriptor_find(name, hash);
+ if(fd) {
+ // found
+ fd->count++;
+ return fd->pos;
+ }
+ // not found
+
+ // check we have enough memory to add it
+ if(!all_files || all_files_len == all_files_size) {
+ void *old = all_files;
+
+ // there is no empty slot
+ if(debug) fprintf(stderr, "apps.plugin: extending fd array to %d entries\n", all_files_size + FILE_DESCRIPTORS_INCREASE_STEP);
+ all_files = realloc(all_files, (all_files_size + FILE_DESCRIPTORS_INCREASE_STEP) * sizeof(struct file_descriptor));
+
+ // if the address changed, we have to rebuild the index
+ // since all pointers are now invalid
+ if(old && old != (void *)all_files) {
+ if(debug) fprintf(stderr, "apps.plugin: re-indexing.\n");
+ all_files_index.root = NULL;
+ int i;
+ for(i = 0; i < all_files_size; i++) {
+ if(!all_files[i].count) continue;
+ file_descriptor_add(&all_files[i]);
+ }
+ }
+
+ if(!all_files_size) all_files_len = 1;
+ all_files_size += FILE_DESCRIPTORS_INCREASE_STEP;
+ }
+
+ // search for an empty slot
+ int i, c;
+ for(i = 0, c = last_pos ; i < all_files_size ; i++, c++) {
+ if(c >= all_files_size) c = 0;
+ if(c == 0) continue;
+
+ if(!all_files[c].count) {
+ if(all_files[c].magic == 0x0BADCAFE && all_files[c].name && file_descriptor_find(all_files[c].name, all_files[c].hash))
+ error("apps.plugin: fd on position %d is not cleared properly. It still has %s in it.\n", c, all_files[c].name);
+
+ if(debug) fprintf(stderr, "apps.plugin: re-using fd position %d for %s (last name: %s)\n", c, name, all_files[c].name);
+ if(all_files[c].name) free((void *)all_files[c].name);
+ all_files[c].name = NULL;
+ break;
+ }
+ }
+ if(i == all_files_size) {
+ error("We should find an empty slot, but there isn't any");
+ return 0;
+ }
+ all_files_len++;
+
+ // else we have an empty slot in 'c'
+
+ int type = FILETYPE_OTHER;
if(name[0] == '/') type = FILETYPE_FILE;
else if(strncmp(name, "pipe:", 5) == 0) type = FILETYPE_PIPE;
else if(strncmp(name, "socket:", 7) == 0) type = FILETYPE_SOCKET;
type = FILETYPE_OTHER;
}
- // init
- if(!all_files) {
- all_files = malloc(1024 * sizeof(struct file_descriptor));
- if(!all_files) return 0;
-
- all_files_size = 1024;
- all_files_len = 1; // start from 1, skip 0
- if(debug) fprintf(stderr, "apps.plugin: initialized fd array to %d entries\n", all_files_size);
- }
-
- // try to find it
- unsigned long hash = simple_hash(name);
- int c;
- for( c = 0 ; c < all_files_len ; c++) {
- if(all_files[c].hash == hash && strcmp(all_files[c].name, name) == 0) break;
- }
-
- // found it
- if(c < all_files_len) {
- all_files[c].count++;
- return c;
- }
-
- // not found, search for an empty slot
- for(c = 0 ; c < all_files_len ; c++) {
- if(!all_files[c].count) {
- if(debug) fprintf(stderr, "apps.plugin: re-using fd position %d (last name: %s)\n", c, all_files[c].name);
- if(all_files[c].name) free(all_files[c].name);
- break;
- }
- }
-
- if(c == all_files_len) {
- // not found any emtpty slot
- all_files_len++;
-
- if(c >= all_files_size) {
- // not enough memory - extend it
- if(debug) fprintf(stderr, "apps.plugin: extending fd array to %d entries\n", all_files_size + 1024);
- all_files = realloc(all_files, (all_files_size + 1024) * sizeof(struct file_descriptor));
- all_files_size += 1024;
- }
- }
- // else we have the slot in 'c'
-
all_files[c].name = strdup(name);
all_files[c].hash = hash;
all_files[c].type = type;
- all_files[c].count++;
+ all_files[c].pos = c;
+ all_files[c].count = 1;
+ all_files[c].magic = 0x0BADCAFE;
+
+ file_descriptor_add(&all_files[c]);
if(debug) fprintf(stderr, "apps.plugin: using fd position %d (name: %s)\n", c, all_files[c].name);
if(fd == -1) {
if(errno != ENOENT && errno != ESRCH) {
if(!count_errors++ || debug)
- fprintf(stderr, "apps.plugin: ERROR: cannot open file '%s' for reading (%d, %s).\n", filename, errno, strerror(errno));
+ error("apps.plugin: ERROR: cannot open file '%s' for reading (%d, %s).", filename, errno, strerror(errno));
}
continue;
}
if(bytes == -1) {
if(!count_errors++ || debug)
- fprintf(stderr, "apps.plugin: ERROR: cannot read from file '%s' (%s).\n", filename, strerror(errno));
+ error("apps.plugin: ERROR: cannot read from file '%s' (%s).", filename, strerror(errno));
continue;
}
if(parsed < 39) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: file %s gave %d results (expected 44)\n", filename, parsed);
+ error("apps.plugin: ERROR: file %s gave %d results (expected 44)\n", filename, parsed);
}
// check if it is target
if(fd == -1) {
if(errno != ENOENT && errno != ESRCH) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: cannot open file '%s' for reading (%d, %s).\n", filename, errno, strerror(errno));
+ error("apps.plugin: ERROR: cannot open file '%s' for reading (%d, %s).", filename, errno, strerror(errno));
}
}
else {
if(bytes == -1) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: cannot read from file '%s' (%s).\n", filename, strerror(errno));
+ error("apps.plugin: ERROR: cannot read from file '%s' (%s).", filename, strerror(errno));
}
else if(bytes > 10) {
buffer[bytes] = '\0';
if(parsed < 7) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: file %s gave %d results (expected 7)\n", filename, parsed);
+ error("apps.plugin: ERROR: file %s gave %d results (expected 7)", filename, parsed);
}
}
}
if(fd == -1) {
if(errno != ENOENT && errno != ESRCH) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: cannot open file '%s' for reading (%d, %s).\n", filename, errno, strerror(errno));
+ error("apps.plugin: ERROR: cannot open file '%s' for reading (%d, %s).", filename, errno, strerror(errno));
}
}
else {
if(bytes == -1) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: cannot read from file '%s' (%s).\n", filename, strerror(errno));
+ error("apps.plugin: ERROR: cannot read from file '%s' (%s).", filename, strerror(errno));
}
else if(bytes > 10) {
buffer[bytes] = '\0';
if(parsed < 7) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: file %s gave %d results (expected 7)\n", filename, parsed);
+ error("apps.plugin: ERROR: file %s gave %d results (expected 7)", filename, parsed);
}
}
}
if(debug) fprintf(stderr, "apps.plugin: extending fd memory slots for %s from %d to %d\n", p->comm, p->fds_size, fdid + 100);
p->fds = realloc(p->fds, (fdid + 100) * sizeof(int));
if(!p->fds) {
- fprintf(stderr, "apps.plugin: ERROR: cannot re-allocate fds for %s\n", p->comm);
+ error("apps.plugin: ERROR: cannot re-allocate fds for %s", p->comm);
break;
}
if(l == -1) {
if(debug || (p->target && p->target->debug)) {
if(!count_errors++ || debug || (p->target && p->target->debug))
- fprintf(stderr, "apps.plugin: ERROR: cannot read link %s\n", fdname);
+ error("apps.plugin: ERROR: cannot read link %s", fdname);
}
continue;
}
p->updated = 1;
}
if(count_errors > 1000) {
- fprintf(stderr, "apps.plugin: ERROR: %ld more errors encountered\n", count_errors - 1);
+ error("apps.plugin: ERROR: %ld more errors encountered\n", count_errors - 1);
count_errors = 0;
}
p->parent = all_pids[p->ppid];
p->parent->childs++;
}
- else if(p->ppid != 0) fprintf(stderr, "apps.plugin: \t\tWRONG! pid %d %s states parent %d, but the later does not exist.\n", p->pid, p->comm, p->ppid);
+ else if(p->ppid != 0) error("apps.plugin: \t\tWRONG! pid %d %s states parent %d, but the later does not exist.", p->pid, p->comm, p->ppid);
}
// find all the procs with 0 childs and merge them to their parents
for(p = root; p ; p = p->next) {
if(p->updated) continue;
- fprintf(stderr, "apps.plugin: UNMERGING %d %s\n", p->pid, p->comm);
+ if(debug) fprintf(stderr, "apps.plugin: UNMERGING %d %s\n", p->pid, p->comm);
unsigned long long diff_utime = p->utime + p->cutime + p->fix_cutime;
unsigned long long diff_stime = p->stime + p->cstime + p->fix_cstime;
diff_utime -= x;
t->diff_cutime -= x;
t->fix_cutime += x;
- fprintf(stderr, "apps.plugin: \t cutime %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
+ if(debug) fprintf(stderr, "apps.plugin: \t cutime %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
}
if(diff_stime && t->diff_cstime) {
x = (t->diff_cstime < diff_stime)?t->diff_cstime:diff_stime;
diff_stime -= x;
t->diff_cstime -= x;
t->fix_cstime += x;
- fprintf(stderr, "apps.plugin: \t cstime %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
+ if(debug) fprintf(stderr, "apps.plugin: \t cstime %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
}
if(diff_minflt && t->diff_cminflt) {
x = (t->diff_cminflt < diff_minflt)?t->diff_cminflt:diff_minflt;
diff_minflt -= x;
t->diff_cminflt -= x;
t->fix_cminflt += x;
- fprintf(stderr, "apps.plugin: \t cminflt %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
+ if(debug) fprintf(stderr, "apps.plugin: \t cminflt %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
}
if(diff_majflt && t->diff_cmajflt) {
x = (t->diff_cmajflt < diff_majflt)?t->diff_cmajflt:diff_majflt;
diff_majflt -= x;
t->diff_cmajflt -= x;
t->fix_cmajflt += x;
- fprintf(stderr, "apps.plugin: \t cmajflt %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
+ if(debug) fprintf(stderr, "apps.plugin: \t cmajflt %llu from %d %s %s\n", x, t->pid, t->comm, t->target->name);
}
}
- if(diff_utime) fprintf(stderr, "apps.plugin: \t cannot fix up utime %llu\n", diff_utime);
- if(diff_stime) fprintf(stderr, "apps.plugin: \t cannot fix up stime %llu\n", diff_stime);
- if(diff_minflt) fprintf(stderr, "apps.plugin: \t cannot fix up minflt %llu\n", diff_minflt);
- if(diff_majflt) fprintf(stderr, "apps.plugin: \t cannot fix up majflt %llu\n", diff_majflt);
+ if(diff_utime) error("apps.plugin: \t cannot fix up utime %llu", diff_utime);
+ if(diff_stime) error("apps.plugin: \t cannot fix up stime %llu", diff_stime);
+ if(diff_minflt) error("apps.plugin: \t cannot fix up minflt %llu", diff_minflt);
+ if(diff_majflt) error("apps.plugin: \t cannot fix up majflt %llu", diff_majflt);
}
#endif
for (w = target_root; w ; w = w->next) {
targets++;
- w->fds = calloc(sizeof(int), all_files_len);
+ w->fds = calloc(sizeof(int), all_files_size);
if(!w->fds)
- fprintf(stderr, "apps.plugin: ERROR: cannot allocate memory for fds in %s\n", w->name);
+ error("apps.plugin: ERROR: cannot allocate memory for fds in %s", w->name);
w->minflt = 0;
w->majflt = 0;
// concentrate everything on the targets
for(p = root; p ; p = p->next) {
if(!p->target) {
- fprintf(stderr, "apps.plugin: ERROR: pid %d %s was left without a target!\n", p->pid, p->comm);
+ error("apps.plugin: ERROR: pid %d %s was left without a target!", p->pid, p->comm);
continue;
}
for(c = 0; c < p->fds_size ;c++) {
if(p->fds[c] == 0) continue;
- if(p->fds[c] > 0 && p->fds[c] < all_files_len) {
+ if(p->fds[c] < all_files_size) {
if(p->target->fds) p->target->fds[p->fds[c]]++;
}
else
- fprintf(stderr, "apps.plugin: ERROR: invalid fd number %d\n", p->fds[c]);
+ error("apps.plugin: ERROR: invalid fd number %d", p->fds[c]);
}
if(debug || p->target->debug) fprintf(stderr, "apps.plugin: \tAgregating %s pid %d on %s utime=%llu, stime=%llu, cutime=%llu, cstime=%llu, minflt=%llu, majflt=%llu, cminflt=%llu, cmajflt=%llu\n", p->comm, p->pid, p->target->name, p->utime, p->stime, p->cutime, p->cstime, p->minflt, p->majflt, p->cminflt, p->cmajflt);
w->openeventpolls = 0;
w->openother = 0;
- for(c = 1; c < all_files_len ;c++) {
+ for(c = 1; c < all_files_size ;c++) {
if(w->fds && w->fds[c] > 0) switch(all_files[c].type) {
case FILETYPE_FILE:
w->openfiles++;
continue;
}
- fprintf(stderr, "apps.plugin: ERROR: cannot understand option %s\n", argv[i]);
+ error("apps.plugin: ERROR: cannot understand option %s", argv[i]);
exit(1);
}
if(!name) name = "groups";
if(read_process_groups(name)) {
- fprintf(stderr, "apps.plugin: ERROR: cannot read process groups %s\n", name);
+ error("apps.plugin: ERROR: cannot read process groups %s", name);
exit(1);
}
}
int main(int argc, char **argv)
{
+ // debug_flags = D_PROCFILE;
+
unsigned long started_t = time(NULL), current_t;
Hertz = get_hertz();
pid_max = get_pid_max();
all_pids = calloc(sizeof(struct pid_stat *), pid_max);
if(!all_pids) {
- fprintf(stderr, "apps.plugin: ERROR: cannot allocate %lu bytes of memory.\n", sizeof(struct pid_stat *) * pid_max);
+ error("apps.plugin: ERROR: cannot allocate %lu bytes of memory.", sizeof(struct pid_stat *) * pid_max);
printf("DISABLE\n");
exit(1);
}
for(;1; counter++) {
if(!update_from_proc()) {
- fprintf(stderr, "apps.plugin: ERROR: cannot allocate %lu bytes of memory.\n", sizeof(struct pid_stat *) * pid_max);
+ error("apps.plugin: ERROR: cannot allocate %lu bytes of memory.", sizeof(struct pid_stat *) * pid_max);
printf("DISABLE\n");
exit(1);
}
break;
}
- RRD_STATS *st = NULL;
+ RRDSET *st = NULL;
unsigned long long count = 0;
while(fgets(line, PLUGINSD_LINE_MAX, fp) != NULL) {
}
if(st->debug) debug(D_PLUGINSD, "PLUGINSD: '%s' is setting dimension %s/%s to %s", cd->fullfilename, st->id, dimension, value);
- rrd_stats_dimension_set(st, dimension, atoll(value));
+ rrddim_set(st, dimension, atoll(value));
count++;
}
break;
}
- st = rrd_stats_find(id);
+ st = rrdset_find(id);
if(!st) {
error("PLUGINSD: '%s' is requesting a BEGIN on chart '%s', which does not exist. Disabling it.", cd->fullfilename, id);
cd->enabled = 0;
if(st->counter_done) {
unsigned long long microseconds = 0;
if(microseconds_txt && *microseconds_txt) microseconds = strtoull(microseconds_txt, NULL, 10);
- if(microseconds) rrd_stats_next_usec(st, microseconds);
- else rrd_stats_next_plugins(st);
+ if(microseconds) rrdset_next_usec(st, microseconds);
+ else rrdset_next_plugins(st);
}
}
else if(!strcmp(s, "END")) {
if(st->debug) debug(D_PLUGINSD, "PLUGINSD: '%s' is requesting a END on chart %s", cd->fullfilename, st->id);
- rrd_stats_done(st);
+ rrdset_done(st);
st = NULL;
}
else if(!strcmp(s, "FLUSH")) {
if(update_every_s) update_every = atoi(update_every_s);
if(!update_every) update_every = cd->update_every;
- int chart_type = CHART_TYPE_LINE;
- if(chart) chart_type = chart_type_id(chart);
+ int chart_type = RRDSET_TYPE_LINE;
+ if(chart) chart_type = rrdset_type_id(chart);
if(!name || !*name) name = NULL;
if(!family || !*family) family = id;
if(!category || !*category) category = type;
- st = rrd_stats_find_bytype(type, id);
+ st = rrdset_find_bytype(type, id);
if(!st) {
debug(D_PLUGINSD, "PLUGINSD: Creating chart type='%s', id='%s', name='%s', family='%s', category='%s', chart='%s', priority=%d, update_every=%d"
, type, id
, name?name:""
, family?family:""
, category?category:""
- , chart_type_name(chart_type)
+ , rrdset_type_name(chart_type)
, priority
, update_every
);
- st = rrd_stats_create(type, id, name, family, title, units, priority, update_every, chart_type);
+ st = rrdset_create(type, id, name, family, title, units, priority, update_every, chart_type);
cd->update_every = update_every;
if(strcmp(category, "none") == 0) st->isdetail = 1;
, st->id
, id
, name?name:""
- , algorithm_name(algorithm_id(algorithm))
+ , rrddim_algorithm_name(rrddim_algorithm_id(algorithm))
, multiplier
, divisor
, hidden?hidden:""
);
- RRD_DIMENSION *rd = rrd_stats_dimension_find(st, id);
+ RRDDIM *rd = rrddim_find(st, id);
if(!rd) {
- rd = rrd_stats_dimension_add(st, id, name, multiplier, divisor, algorithm_id(algorithm));
+ rd = rrddim_add(st, id, name, multiplier, divisor, rrddim_algorithm_id(algorithm));
if(hidden && strcmp(hidden, "hidden") == 0) rd->hidden = 1;
}
else if(st->debug) debug(D_PLUGINSD, "PLUGINSD: dimension %s/%s already exists. Not adding it again.", st->id, id);
gettimeofday(&now, NULL);
if(!usec && !susec) {
// our first run
- susec = cd->update_every * 1000000ULL;
+ susec = cd->rrd_update_every * 1000000ULL;
}
else {
// second+ run
usec = usecdiff(&now, &last) - susec;
error("PLUGINSD: %s last loop took %llu usec (worked for %llu, sleeped for %llu).\n", cd->fullfilename, usec + susec, usec, susec);
- if(usec < (update_every * 1000000ULL / 2ULL)) susec = (update_every * 1000000ULL) - usec;
- else susec = update_every * 1000000ULL / 2ULL;
+ if(usec < (rrd_update_every * 1000000ULL / 2ULL)) susec = (rrd_update_every * 1000000ULL) - usec;
+ else susec = rrd_update_every * 1000000ULL / 2ULL;
}
error("PLUGINSD: %s sleeping for %llu. Will kill with SIGCONT pid %d to wake it up.\n", cd->fullfilename, susec, cd->pid);
snprintf(cd->fullfilename, FILENAME_MAX, "%s/%s", dir_name, cd->filename);
cd->enabled = enabled;
- cd->update_every = config_get_number(cd->id, "update every", update_every);
+ cd->update_every = config_get_number(cd->id, "update every", rrd_update_every);
cd->started_t = time(NULL);
char *def = "";
if(!config_get_boolean("plugin:proc:/proc/diskstats", var_name, def_enabled)) continue;
}
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_io) {
- st = rrd_stats_find_bytype(RRD_TYPE_DISK, disk);
+ st = rrdset_find_bytype(RRD_TYPE_DISK, disk);
if(!st) {
char tf[FILENAME_MAX + 1], *t;
char ssfilename[FILENAME_MAX + 1];
}
else error("Cannot read sector size for device %s from %s. Assuming 512.", disk, ssfilename);
- st = rrd_stats_create(RRD_TYPE_DISK, disk, NULL, disk, "Disk I/O", "kilobytes/s", 2000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create(RRD_TYPE_DISK, disk, NULL, disk, "Disk I/O", "kilobytes/s", 2000, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "reads", NULL, sector_size, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "writes", NULL, sector_size * -1, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "reads", NULL, sector_size, 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "writes", NULL, sector_size * -1, 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "reads", readsectors);
- rrd_stats_dimension_set(st, "writes", writesectors);
- rrd_stats_done(st);
+ rrddim_set(st, "reads", readsectors);
+ rrddim_set(st, "writes", writesectors);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ops) {
- st = rrd_stats_find_bytype("disk_ops", disk);
+ st = rrdset_find_bytype("disk_ops", disk);
if(!st) {
- st = rrd_stats_create("disk_ops", disk, NULL, disk, "Disk Operations", "operations/s", 2001, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("disk_ops", disk, NULL, disk, "Disk Operations", "operations/s", 2001, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "reads", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "writes", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "reads", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "writes", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "reads", reads);
- rrd_stats_dimension_set(st, "writes", writes);
- rrd_stats_done(st);
+ rrddim_set(st, "reads", reads);
+ rrddim_set(st, "writes", writes);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_merged_ops) {
- st = rrd_stats_find_bytype("disk_merged_ops", disk);
+ st = rrdset_find_bytype("disk_merged_ops", disk);
if(!st) {
- st = rrd_stats_create("disk_merged_ops", disk, NULL, disk, "Merged Disk Operations", "operations/s", 2010, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("disk_merged_ops", disk, NULL, disk, "Merged Disk Operations", "operations/s", 2010, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "reads", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "writes", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "reads", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "writes", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "reads", reads_merged);
- rrd_stats_dimension_set(st, "writes", writes_merged);
- rrd_stats_done(st);
+ rrddim_set(st, "reads", reads_merged);
+ rrddim_set(st, "writes", writes_merged);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_iotime) {
- st = rrd_stats_find_bytype("disk_iotime", disk);
+ st = rrdset_find_bytype("disk_iotime", disk);
if(!st) {
- st = rrd_stats_create("disk_iotime", disk, NULL, disk, "Disk I/O Time", "milliseconds/s", 2005, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("disk_iotime", disk, NULL, disk, "Disk I/O Time", "milliseconds/s", 2005, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "reads", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "writes", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "latency", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "weighted", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "reads", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "writes", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "latency", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "weighted", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "reads", readms);
- rrd_stats_dimension_set(st, "writes", writems);
- rrd_stats_dimension_set(st, "latency", iosms);
- rrd_stats_dimension_set(st, "weighted", wiosms);
- rrd_stats_done(st);
+ rrddim_set(st, "reads", readms);
+ rrddim_set(st, "writes", writems);
+ rrddim_set(st, "latency", iosms);
+ rrddim_set(st, "weighted", wiosms);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_cur_ops) {
- st = rrd_stats_find_bytype("disk_cur_ops", disk);
+ st = rrdset_find_bytype("disk_cur_ops", disk);
if(!st) {
- st = rrd_stats_create("disk_cur_ops", disk, NULL, disk, "Current Disk I/O operations", "operations", 2004, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("disk_cur_ops", disk, NULL, disk, "Current Disk I/O operations", "operations", 2004, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "operations", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "operations", NULL, 1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "operations", currentios);
- rrd_stats_done(st);
+ rrddim_set(st, "operations", currentios);
+ rrdset_done(st);
}
}
else if(!DirectMap2M && strcmp(name, "DirectMap2M") == 0) DirectMap2M = value;
}
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
unsigned long long MemUsed = MemTotal - MemFree - Cached - Buffers;
if(do_ram) {
- st = rrd_stats_find("system.ram");
+ st = rrdset_find("system.ram");
if(!st) {
- st = rrd_stats_create("system", "ram", NULL, "mem", "System RAM", "MB", 200, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("system", "ram", NULL, "mem", "System RAM", "MB", 200, update_every, RRDSET_TYPE_STACKED);
- rrd_stats_dimension_add(st, "buffers", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "used", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "cached", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "free", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "buffers", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "used", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "cached", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "free", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "used", MemUsed);
- rrd_stats_dimension_set(st, "free", MemFree);
- rrd_stats_dimension_set(st, "cached", Cached);
- rrd_stats_dimension_set(st, "buffers", Buffers);
- rrd_stats_done(st);
+ rrddim_set(st, "used", MemUsed);
+ rrddim_set(st, "free", MemFree);
+ rrddim_set(st, "cached", Cached);
+ rrddim_set(st, "buffers", Buffers);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
unsigned long long SwapUsed = SwapTotal - SwapFree;
if(do_swap) {
- st = rrd_stats_find("system.swap");
+ st = rrdset_find("system.swap");
if(!st) {
- st = rrd_stats_create("system", "swap", NULL, "mem", "System Swap", "MB", 201, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("system", "swap", NULL, "mem", "System Swap", "MB", 201, update_every, RRDSET_TYPE_STACKED);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "free", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "used", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "free", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "used", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "used", SwapUsed);
- rrd_stats_dimension_set(st, "free", SwapFree);
- rrd_stats_done(st);
+ rrddim_set(st, "used", SwapUsed);
+ rrddim_set(st, "free", SwapFree);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(hwcorrupted && do_hwcorrupt) {
- st = rrd_stats_find("mem.hwcorrupt");
+ st = rrdset_find("mem.hwcorrupt");
if(!st) {
- st = rrd_stats_create("mem", "hwcorrupt", NULL, "mem", "Hardware Corrupted ECC", "MB", 9000, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("mem", "hwcorrupt", NULL, "mem", "Hardware Corrupted ECC", "MB", 9000, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "HardwareCorrupted", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "HardwareCorrupted", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "HardwareCorrupted", HardwareCorrupted);
- rrd_stats_done(st);
+ rrddim_set(st, "HardwareCorrupted", HardwareCorrupted);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_committed) {
- st = rrd_stats_find("mem.committed");
+ st = rrdset_find("mem.committed");
if(!st) {
- st = rrd_stats_create("mem", "committed", NULL, "mem", "Committed (Allocated) Memory", "MB", 5000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("mem", "committed", NULL, "mem", "Committed (Allocated) Memory", "MB", 5000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "Committed_AS", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "Committed_AS", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "Committed_AS", Committed_AS);
- rrd_stats_done(st);
+ rrddim_set(st, "Committed_AS", Committed_AS);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_writeback) {
- st = rrd_stats_find("mem.writeback");
+ st = rrdset_find("mem.writeback");
if(!st) {
- st = rrd_stats_create("mem", "writeback", NULL, "mem", "Writeback Memory", "MB", 4000, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("mem", "writeback", NULL, "mem", "Writeback Memory", "MB", 4000, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "Dirty", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "Writeback", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "FuseWriteback", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "NfsWriteback", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "Bounce", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "Dirty", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "Writeback", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "FuseWriteback", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "NfsWriteback", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "Bounce", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
-
- rrd_stats_dimension_set(st, "Dirty", Dirty);
- rrd_stats_dimension_set(st, "Writeback", Writeback);
- rrd_stats_dimension_set(st, "FuseWriteback", WritebackTmp);
- rrd_stats_dimension_set(st, "NfsWriteback", NFS_Unstable);
- rrd_stats_dimension_set(st, "Bounce", Bounce);
- rrd_stats_done(st);
+ else rrdset_next(st);
+
+ rrddim_set(st, "Dirty", Dirty);
+ rrddim_set(st, "Writeback", Writeback);
+ rrddim_set(st, "FuseWriteback", WritebackTmp);
+ rrddim_set(st, "NfsWriteback", NFS_Unstable);
+ rrddim_set(st, "Bounce", Bounce);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_kernel) {
- st = rrd_stats_find("mem.kernel");
+ st = rrdset_find("mem.kernel");
if(!st) {
- st = rrd_stats_create("mem", "kernel", NULL, "mem", "Memory Used by Kernel", "MB", 6000, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("mem", "kernel", NULL, "mem", "Memory Used by Kernel", "MB", 6000, update_every, RRDSET_TYPE_STACKED);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "Slab", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "KernelStack", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "PageTables", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "VmallocUsed", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "Slab", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "KernelStack", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "PageTables", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "VmallocUsed", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "KernelStack", KernelStack);
- rrd_stats_dimension_set(st, "Slab", Slab);
- rrd_stats_dimension_set(st, "PageTables", PageTables);
- rrd_stats_dimension_set(st, "VmallocUsed", VmallocUsed);
- rrd_stats_done(st);
+ rrddim_set(st, "KernelStack", KernelStack);
+ rrddim_set(st, "Slab", Slab);
+ rrddim_set(st, "PageTables", PageTables);
+ rrddim_set(st, "VmallocUsed", VmallocUsed);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_slab) {
- st = rrd_stats_find("mem.slab");
+ st = rrdset_find("mem.slab");
if(!st) {
- st = rrd_stats_create("mem", "slab", NULL, "mem", "Reclaimable Kernel Memory", "MB", 6500, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("mem", "slab", NULL, "mem", "Reclaimable Kernel Memory", "MB", 6500, update_every, RRDSET_TYPE_STACKED);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "reclaimable", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "unreclaimable", NULL, 1, 1024, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "reclaimable", NULL, 1, 1024, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "unreclaimable", NULL, 1, 1024, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "reclaimable", SReclaimable);
- rrd_stats_dimension_set(st, "unreclaimable", SUnreclaim);
- rrd_stats_done(st);
+ rrddim_set(st, "reclaimable", SReclaimable);
+ rrddim_set(st, "unreclaimable", SUnreclaim);
+ rrdset_done(st);
}
return 0;
if(!config_get_boolean("plugin:proc:/proc/net/dev", var_name, enable_new_interfaces)) continue;
}
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_bandwidth) {
- st = rrd_stats_find_bytype("net", iface);
+ st = rrdset_find_bytype("net", iface);
if(!st) {
- st = rrd_stats_create("net", iface, NULL, iface, "Bandwidth", "kilobits/s", 1000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("net", iface, NULL, iface, "Bandwidth", "kilobits/s", 1000, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "received", NULL, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 8, 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -8, 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", rbytes);
- rrd_stats_dimension_set(st, "sent", tbytes);
- rrd_stats_done(st);
+ rrddim_set(st, "received", rbytes);
+ rrddim_set(st, "sent", tbytes);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_packets) {
- st = rrd_stats_find_bytype("net_packets", iface);
+ st = rrdset_find_bytype("net_packets", iface);
if(!st) {
- st = rrd_stats_create("net_packets", iface, NULL, iface, "Packets", "packets/s", 1001, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("net_packets", iface, NULL, iface, "Packets", "packets/s", 1001, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "multicast", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "multicast", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", rpackets);
- rrd_stats_dimension_set(st, "sent", tpackets);
- rrd_stats_dimension_set(st, "multicast", rmulticast);
- rrd_stats_done(st);
+ rrddim_set(st, "received", rpackets);
+ rrddim_set(st, "sent", tpackets);
+ rrddim_set(st, "multicast", rmulticast);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_errors) {
- st = rrd_stats_find_bytype("net_errors", iface);
+ st = rrdset_find_bytype("net_errors", iface);
if(!st) {
- st = rrd_stats_create("net_errors", iface, NULL, iface, "Interface Errors", "errors/s", 1002, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("net_errors", iface, NULL, iface, "Interface Errors", "errors/s", 1002, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "inbound", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "outbound", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "inbound", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "outbound", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "inbound", rerrors);
- rrd_stats_dimension_set(st, "outbound", terrors);
- rrd_stats_done(st);
+ rrddim_set(st, "inbound", rerrors);
+ rrddim_set(st, "outbound", terrors);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_drops) {
- st = rrd_stats_find_bytype("net_drops", iface);
+ st = rrdset_find_bytype("net_drops", iface);
if(!st) {
- st = rrd_stats_create("net_drops", iface, NULL, iface, "Interface Drops", "drops/s", 1003, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("net_drops", iface, NULL, iface, "Interface Drops", "drops/s", 1003, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "inbound", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "outbound", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "inbound", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "outbound", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "inbound", rdrops);
- rrd_stats_dimension_set(st, "outbound", tdrops);
- rrd_stats_done(st);
+ rrddim_set(st, "inbound", rdrops);
+ rrddim_set(st, "outbound", tdrops);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_fifo) {
- st = rrd_stats_find_bytype("net_fifo", iface);
+ st = rrdset_find_bytype("net_fifo", iface);
if(!st) {
- st = rrd_stats_create("net_fifo", iface, NULL, iface, "Interface Queue", "packets", 1100, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("net_fifo", iface, NULL, iface, "Interface Queue", "packets", 1100, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "receive", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "transmit", NULL, -1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "receive", NULL, 1, 1, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "transmit", NULL, -1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "receive", rfifo);
- rrd_stats_dimension_set(st, "transmit", tfifo);
- rrd_stats_done(st);
+ rrddim_set(st, "receive", rfifo);
+ rrddim_set(st, "transmit", tfifo);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_compressed) {
- st = rrd_stats_find_bytype("net_compressed", iface);
+ st = rrdset_find_bytype("net_compressed", iface);
if(!st) {
- st = rrd_stats_create("net_compressed", iface, NULL, iface, "Compressed Packets", "packets/s", 1200, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("net_compressed", iface, NULL, iface, "Compressed Packets", "packets/s", 1200, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", rcompressed);
- rrd_stats_dimension_set(st, "sent", tcompressed);
- rrd_stats_done(st);
+ rrddim_set(st, "received", rcompressed);
+ rrddim_set(st, "sent", tcompressed);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_events) {
- st = rrd_stats_find_bytype("net_events", iface);
+ st = rrdset_find_bytype("net_events", iface);
if(!st) {
- st = rrd_stats_create("net_events", iface, NULL, iface, "Network Interface Events", "events/s", 1200, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("net_events", iface, NULL, iface, "Network Interface Events", "events/s", 1200, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "frames", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "collisions", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "carrier", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "frames", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "collisions", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "carrier", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "frames", rframe);
- rrd_stats_dimension_set(st, "collisions", tcollisions);
- rrd_stats_dimension_set(st, "carrier", tcarrier);
- rrd_stats_done(st);
+ rrddim_set(st, "frames", rframe);
+ rrddim_set(st, "collisions", tcollisions);
+ rrddim_set(st, "carrier", tcarrier);
+ rrdset_done(st);
}
}
InBytes = strtoull(procfile_lineword(ff, 2, 3), NULL, 16);
OutBytes = strtoull(procfile_lineword(ff, 2, 4), NULL, 16);
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_sockets) {
- st = rrd_stats_find(RRD_TYPE_NET_IPVS ".sockets");
+ st = rrdset_find(RRD_TYPE_NET_IPVS ".sockets");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_IPVS, "sockets", NULL, RRD_TYPE_NET_IPVS, "IPVS New Connections", "connections/s", 1001, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_IPVS, "sockets", NULL, RRD_TYPE_NET_IPVS, "IPVS New Connections", "connections/s", 1001, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "connections", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "connections", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "connections", entries);
- rrd_stats_done(st);
+ rrddim_set(st, "connections", entries);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_packets) {
- st = rrd_stats_find(RRD_TYPE_NET_IPVS ".packets");
+ st = rrdset_find(RRD_TYPE_NET_IPVS ".packets");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_IPVS, "packets", NULL, RRD_TYPE_NET_IPVS, "IPVS Packets", "packets/s", 1002, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_IPVS, "packets", NULL, RRD_TYPE_NET_IPVS, "IPVS Packets", "packets/s", 1002, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", InPackets);
- rrd_stats_dimension_set(st, "sent", OutPackets);
- rrd_stats_done(st);
+ rrddim_set(st, "received", InPackets);
+ rrddim_set(st, "sent", OutPackets);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bandwidth) {
- st = rrd_stats_find(RRD_TYPE_NET_IPVS ".net");
+ st = rrdset_find(RRD_TYPE_NET_IPVS ".net");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_IPVS, "net", NULL, RRD_TYPE_NET_IPVS, "IPVS Bandwidth", "kilobits/s", 1000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create(RRD_TYPE_NET_IPVS, "net", NULL, RRD_TYPE_NET_IPVS, "IPVS Bandwidth", "kilobits/s", 1000, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "received", NULL, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 8, 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -8, 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", InBytes);
- rrd_stats_dimension_set(st, "sent", OutBytes);
- rrd_stats_done(st);
+ rrddim_set(st, "received", InBytes);
+ rrddim_set(st, "sent", OutBytes);
+ rrdset_done(st);
}
return 0;
InBcastOctets = strtoull(procfile_lineword(ff, l, 11), NULL, 10);
OutBcastOctets = strtoull(procfile_lineword(ff, l, 12), NULL, 10);
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_bandwidth) {
- st = rrd_stats_find("system.ipv4");
+ st = rrdset_find("system.ipv4");
if(!st) {
- st = rrd_stats_create("system", "ipv4", NULL, "ipv4", "IPv4 Bandwidth", "kilobits/s", 2000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("system", "ipv4", NULL, "ipv4", "IPv4 Bandwidth", "kilobits/s", 2000, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "received", NULL, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 8, 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -8, 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "sent", OutOctets);
- rrd_stats_dimension_set(st, "received", InOctets);
- rrd_stats_done(st);
+ rrddim_set(st, "sent", OutOctets);
+ rrddim_set(st, "received", InOctets);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_inerrors) {
- st = rrd_stats_find("ipv4.inerrors");
+ st = rrdset_find("ipv4.inerrors");
if(!st) {
- st = rrd_stats_create("ipv4", "inerrors", NULL, "ipv4", "IPv4 Input Errors", "packets/s", 4000, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("ipv4", "inerrors", NULL, "ipv4", "IPv4 Input Errors", "packets/s", 4000, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "noroutes", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "trunkated", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "noroutes", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "trunkated", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "noroutes", InNoRoutes);
- rrd_stats_dimension_set(st, "trunkated", InTruncatedPkts);
- rrd_stats_done(st);
+ rrddim_set(st, "noroutes", InNoRoutes);
+ rrddim_set(st, "trunkated", InTruncatedPkts);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_mcast) {
- st = rrd_stats_find("ipv4.mcast");
+ st = rrdset_find("ipv4.mcast");
if(!st) {
- st = rrd_stats_create("ipv4", "mcast", NULL, "ipv4", "IPv4 Multicast Bandwidth", "kilobits/s", 9000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("ipv4", "mcast", NULL, "ipv4", "IPv4 Multicast Bandwidth", "kilobits/s", 9000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "received", NULL, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 8, 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -8, 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "sent", OutMcastOctets);
- rrd_stats_dimension_set(st, "received", InMcastOctets);
- rrd_stats_done(st);
+ rrddim_set(st, "sent", OutMcastOctets);
+ rrddim_set(st, "received", InMcastOctets);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bcast) {
- st = rrd_stats_find("ipv4.bcast");
+ st = rrdset_find("ipv4.bcast");
if(!st) {
- st = rrd_stats_create("ipv4", "bcast", NULL, "ipv4", "IPv4 Broadcast Bandwidth", "kilobits/s", 8000, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("ipv4", "bcast", NULL, "ipv4", "IPv4 Broadcast Bandwidth", "kilobits/s", 8000, update_every, RRDSET_TYPE_AREA);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "received", NULL, 8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -8, 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 8, 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -8, 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "sent", OutBcastOctets);
- rrd_stats_dimension_set(st, "received", InBcastOctets);
- rrd_stats_done(st);
+ rrddim_set(st, "sent", OutBcastOctets);
+ rrddim_set(st, "received", InBcastOctets);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_mcast_p) {
- st = rrd_stats_find("ipv4.mcastpkts");
+ st = rrdset_find("ipv4.mcastpkts");
if(!st) {
- st = rrd_stats_create("ipv4", "mcastpkts", NULL, "ipv4", "IPv4 Multicast Packets", "packets/s", 9500, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("ipv4", "mcastpkts", NULL, "ipv4", "IPv4 Multicast Packets", "packets/s", 9500, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "sent", OutMcastPkts);
- rrd_stats_dimension_set(st, "received", InMcastPkts);
- rrd_stats_done(st);
+ rrddim_set(st, "sent", OutMcastPkts);
+ rrddim_set(st, "received", InMcastPkts);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_bcast_p) {
- st = rrd_stats_find("ipv4.bcastpkts");
+ st = rrdset_find("ipv4.bcastpkts");
if(!st) {
- st = rrd_stats_create("ipv4", "bcastpkts", NULL, "ipv4", "IPv4 Broadcast Packets", "packets/s", 8500, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("ipv4", "bcastpkts", NULL, "ipv4", "IPv4 Broadcast Packets", "packets/s", 8500, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "sent", OutBcastPkts);
- rrd_stats_dimension_set(st, "received", InBcastPkts);
- rrd_stats_done(st);
+ rrddim_set(st, "sent", OutBcastPkts);
+ rrddim_set(st, "received", InBcastPkts);
+ rrdset_done(st);
}
}
}
}
}
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_rc == 2) {
- st = rrd_stats_find_bytype("nfsd", "readcache");
+ st = rrdset_find_bytype("nfsd", "readcache");
if(!st) {
- st = rrd_stats_create("nfsd", "readcache", NULL, "nfsd", "Read Cache", "reads/s", 5000, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfsd", "readcache", NULL, "nfsd", "Read Cache", "reads/s", 5000, update_every, RRDSET_TYPE_STACKED);
- rrd_stats_dimension_add(st, "hits", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "misses", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "nocache", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "hits", NULL, 1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "misses", NULL, 1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "nocache", NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "hits", rc_hits);
- rrd_stats_dimension_set(st, "misses", rc_misses);
- rrd_stats_dimension_set(st, "nocache", rc_nocache);
- rrd_stats_done(st);
+ rrddim_set(st, "hits", rc_hits);
+ rrddim_set(st, "misses", rc_misses);
+ rrddim_set(st, "nocache", rc_nocache);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_fh == 2) {
- st = rrd_stats_find_bytype("nfsd", "filehandles");
+ st = rrdset_find_bytype("nfsd", "filehandles");
if(!st) {
- st = rrd_stats_create("nfsd", "filehandles", NULL, "nfsd", "File Handles", "handles/s", 5001, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("nfsd", "filehandles", NULL, "nfsd", "File Handles", "handles/s", 5001, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "stale", NULL, 1, update_every, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "total_lookups", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "anonymous_lookups", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "dir_not_in_dcache", NULL, -1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "non_dir_not_in_dcache", NULL, -1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "stale", NULL, 1, update_every, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "total_lookups", NULL, 1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "anonymous_lookups", NULL, 1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "dir_not_in_dcache", NULL, -1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "non_dir_not_in_dcache", NULL, -1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
-
- rrd_stats_dimension_set(st, "stale", fh_stale);
- rrd_stats_dimension_set(st, "total_lookups", fh_total_lookups);
- rrd_stats_dimension_set(st, "anonymous_lookups", fh_anonymous_lookups);
- rrd_stats_dimension_set(st, "dir_not_in_dcache", fh_dir_not_in_dcache);
- rrd_stats_dimension_set(st, "non_dir_not_in_dcache", fh_non_dir_not_in_dcache);
- rrd_stats_done(st);
+ else rrdset_next(st);
+
+ rrddim_set(st, "stale", fh_stale);
+ rrddim_set(st, "total_lookups", fh_total_lookups);
+ rrddim_set(st, "anonymous_lookups", fh_anonymous_lookups);
+ rrddim_set(st, "dir_not_in_dcache", fh_dir_not_in_dcache);
+ rrddim_set(st, "non_dir_not_in_dcache", fh_non_dir_not_in_dcache);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_io == 2) {
- st = rrd_stats_find_bytype("nfsd", "io");
+ st = rrdset_find_bytype("nfsd", "io");
if(!st) {
- st = rrd_stats_create("nfsd", "io", NULL, "nfsd", "I/O", "kilobytes/s", 5002, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("nfsd", "io", NULL, "nfsd", "I/O", "kilobytes/s", 5002, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "read", NULL, 1, 1000 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "write", NULL, -1, 1000 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "read", NULL, 1, 1000 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "write", NULL, -1, 1000 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "read", io_read);
- rrd_stats_dimension_set(st, "write", io_write);
- rrd_stats_done(st);
+ rrddim_set(st, "read", io_read);
+ rrddim_set(st, "write", io_write);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_th == 2) {
- st = rrd_stats_find_bytype("nfsd", "threads");
+ st = rrdset_find_bytype("nfsd", "threads");
if(!st) {
- st = rrd_stats_create("nfsd", "threads", NULL, "nfsd", "Threads", "threads", 5003, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("nfsd", "threads", NULL, "nfsd", "Threads", "threads", 5003, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "threads", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "threads", NULL, 1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "threads", th_threads);
- rrd_stats_done(st);
+ rrddim_set(st, "threads", th_threads);
+ rrdset_done(st);
- st = rrd_stats_find_bytype("nfsd", "threads_fullcnt");
+ st = rrdset_find_bytype("nfsd", "threads_fullcnt");
if(!st) {
- st = rrd_stats_create("nfsd", "threads_fullcnt", NULL, "nfsd", "Threads Full Count", "ops/s", 5004, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("nfsd", "threads_fullcnt", NULL, "nfsd", "Threads Full Count", "ops/s", 5004, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "full_count", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "full_count", NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "full_count", th_fullcnt);
- rrd_stats_done(st);
+ rrddim_set(st, "full_count", th_fullcnt);
+ rrdset_done(st);
- st = rrd_stats_find_bytype("nfsd", "threads_histogram");
+ st = rrdset_find_bytype("nfsd", "threads_histogram");
if(!st) {
- st = rrd_stats_create("nfsd", "threads_histogram", NULL, "nfsd", "Threads Usage Histogram", "percentage", 5005, update_every, CHART_TYPE_LINE);
-
- rrd_stats_dimension_add(st, "0%-10%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "10%-20%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "20%-30%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "30%-40%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "40%-50%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "50%-60%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "60%-70%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "70%-80%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "80%-90%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "90%-100%", NULL, 1, 1000, RRD_DIMENSION_ABSOLUTE);
+ st = rrdset_create("nfsd", "threads_histogram", NULL, "nfsd", "Threads Usage Histogram", "percentage", 5005, update_every, RRDSET_TYPE_LINE);
+
+ rrddim_add(st, "0%-10%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "10%-20%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "20%-30%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "30%-40%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "40%-50%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "50%-60%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "60%-70%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "70%-80%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "80%-90%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "90%-100%", NULL, 1, 1000, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
-
- rrd_stats_dimension_set(st, "0%-10%", th_hist10);
- rrd_stats_dimension_set(st, "10%-20%", th_hist20);
- rrd_stats_dimension_set(st, "20%-30%", th_hist30);
- rrd_stats_dimension_set(st, "30%-40%", th_hist40);
- rrd_stats_dimension_set(st, "40%-50%", th_hist50);
- rrd_stats_dimension_set(st, "50%-60%", th_hist60);
- rrd_stats_dimension_set(st, "60%-70%", th_hist70);
- rrd_stats_dimension_set(st, "70%-80%", th_hist80);
- rrd_stats_dimension_set(st, "80%-90%", th_hist90);
- rrd_stats_dimension_set(st, "90%-100%", th_hist100);
- rrd_stats_done(st);
+ else rrdset_next(st);
+
+ rrddim_set(st, "0%-10%", th_hist10);
+ rrddim_set(st, "10%-20%", th_hist20);
+ rrddim_set(st, "20%-30%", th_hist30);
+ rrddim_set(st, "30%-40%", th_hist40);
+ rrddim_set(st, "40%-50%", th_hist50);
+ rrddim_set(st, "50%-60%", th_hist60);
+ rrddim_set(st, "60%-70%", th_hist70);
+ rrddim_set(st, "70%-80%", th_hist80);
+ rrddim_set(st, "80%-90%", th_hist90);
+ rrddim_set(st, "90%-100%", th_hist100);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ra == 2) {
- st = rrd_stats_find_bytype("nfsd", "readahead");
+ st = rrdset_find_bytype("nfsd", "readahead");
if(!st) {
- st = rrd_stats_create("nfsd", "readahead", NULL, "nfsd", "Read Ahead Depth", "percentage", 5005, update_every, CHART_TYPE_STACKED);
-
- rrd_stats_dimension_add(st, "10%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "20%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "30%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "40%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "50%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "60%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "70%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "80%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "90%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "100%", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "misses", NULL, 1, update_every, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
+ st = rrdset_create("nfsd", "readahead", NULL, "nfsd", "Read Ahead Depth", "percentage", 5005, update_every, RRDSET_TYPE_STACKED);
+
+ rrddim_add(st, "10%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "20%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "30%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "40%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "50%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "60%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "70%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "80%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "90%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "100%", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "misses", NULL, 1, update_every, RRDDIM_PCENT_OVER_DIFF_TOTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
// ignore ra_size
if(ra_size) {};
- rrd_stats_dimension_set(st, "10%", ra_hist10);
- rrd_stats_dimension_set(st, "20%", ra_hist20);
- rrd_stats_dimension_set(st, "30%", ra_hist30);
- rrd_stats_dimension_set(st, "40%", ra_hist40);
- rrd_stats_dimension_set(st, "50%", ra_hist50);
- rrd_stats_dimension_set(st, "60%", ra_hist60);
- rrd_stats_dimension_set(st, "70%", ra_hist70);
- rrd_stats_dimension_set(st, "80%", ra_hist80);
- rrd_stats_dimension_set(st, "90%", ra_hist90);
- rrd_stats_dimension_set(st, "100%", ra_hist100);
- rrd_stats_dimension_set(st, "misses", ra_none);
- rrd_stats_done(st);
+ rrddim_set(st, "10%", ra_hist10);
+ rrddim_set(st, "20%", ra_hist20);
+ rrddim_set(st, "30%", ra_hist30);
+ rrddim_set(st, "40%", ra_hist40);
+ rrddim_set(st, "50%", ra_hist50);
+ rrddim_set(st, "60%", ra_hist60);
+ rrddim_set(st, "70%", ra_hist70);
+ rrddim_set(st, "80%", ra_hist80);
+ rrddim_set(st, "90%", ra_hist90);
+ rrddim_set(st, "100%", ra_hist100);
+ rrddim_set(st, "misses", ra_none);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_net == 2) {
- st = rrd_stats_find_bytype("nfsd", "net");
+ st = rrdset_find_bytype("nfsd", "net");
if(!st) {
- st = rrd_stats_create("nfsd", "net", NULL, "nfsd", "Network Reads", "reads/s", 5007, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfsd", "net", NULL, "nfsd", "Network Reads", "reads/s", 5007, update_every, RRDSET_TYPE_STACKED);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "udp", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "tcp", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "udp", NULL, 1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "tcp", NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
// ignore net_count, net_tcp_connections
if(net_count) {};
if(net_tcp_connections) {};
- rrd_stats_dimension_set(st, "udp", net_udp_count);
- rrd_stats_dimension_set(st, "tcp", net_tcp_count);
- rrd_stats_done(st);
+ rrddim_set(st, "udp", net_udp_count);
+ rrddim_set(st, "tcp", net_tcp_count);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_rpc == 2) {
- st = rrd_stats_find_bytype("nfsd", "rpc");
+ st = rrdset_find_bytype("nfsd", "rpc");
if(!st) {
- st = rrd_stats_create("nfsd", "rpc", NULL, "nfsd", "Remote Procedure Calls", "calls/s", 5008, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("nfsd", "rpc", NULL, "nfsd", "Remote Procedure Calls", "calls/s", 5008, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "all", NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "bad_format", NULL, -1, update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "bad_auth", NULL, -1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "all", NULL, 1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "bad_format", NULL, -1, update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "bad_auth", NULL, -1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
// ignore rpc_bad_client
if(rpc_bad_client) {};
- rrd_stats_dimension_set(st, "all", rpc_count);
- rrd_stats_dimension_set(st, "bad_format", rpc_bad_format);
- rrd_stats_dimension_set(st, "bad_auth", rpc_bad_auth);
- rrd_stats_done(st);
+ rrddim_set(st, "all", rpc_count);
+ rrddim_set(st, "bad_format", rpc_bad_format);
+ rrddim_set(st, "bad_auth", rpc_bad_auth);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_proc2 == 2) {
unsigned int i;
- st = rrd_stats_find_bytype("nfsd", "proc2");
+ st = rrdset_find_bytype("nfsd", "proc2");
if(!st) {
- st = rrd_stats_create("nfsd", "proc2", NULL, "nfsd", "NFS v2 Calls", "calls/s", 5009, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfsd", "proc2", NULL, "nfsd", "NFS v2 Calls", "calls/s", 5009, update_every, RRDSET_TYPE_STACKED);
for(i = 0; nfsd_proc_values[i].present2 ; i++)
- rrd_stats_dimension_add(st, nfsd_proc_values[i].name, NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, nfsd_proc_values[i].name, NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
for(i = 0; nfsd_proc_values[i].present2 ; i++)
- rrd_stats_dimension_set(st, nfsd_proc_values[i].name, nfsd_proc_values[i].proc2);
+ rrddim_set(st, nfsd_proc_values[i].name, nfsd_proc_values[i].proc2);
- rrd_stats_done(st);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_proc3 == 2) {
unsigned int i;
- st = rrd_stats_find_bytype("nfsd", "proc3");
+ st = rrdset_find_bytype("nfsd", "proc3");
if(!st) {
- st = rrd_stats_create("nfsd", "proc3", NULL, "nfsd", "NFS v3 Calls", "calls/s", 5010, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfsd", "proc3", NULL, "nfsd", "NFS v3 Calls", "calls/s", 5010, update_every, RRDSET_TYPE_STACKED);
for(i = 0; nfsd_proc_values[i].present3 ; i++)
- rrd_stats_dimension_add(st, nfsd_proc_values[i].name, NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, nfsd_proc_values[i].name, NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
for(i = 0; nfsd_proc_values[i].present3 ; i++)
- rrd_stats_dimension_set(st, nfsd_proc_values[i].name, nfsd_proc_values[i].proc3);
+ rrddim_set(st, nfsd_proc_values[i].name, nfsd_proc_values[i].proc3);
- rrd_stats_done(st);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_proc4 == 2) {
unsigned int i;
- st = rrd_stats_find_bytype("nfsd", "proc4");
+ st = rrdset_find_bytype("nfsd", "proc4");
if(!st) {
- st = rrd_stats_create("nfsd", "proc4", NULL, "nfsd", "NFS v4 Calls", "calls/s", 5011, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfsd", "proc4", NULL, "nfsd", "NFS v4 Calls", "calls/s", 5011, update_every, RRDSET_TYPE_STACKED);
for(i = 0; nfsd_proc_values[i].present4 ; i++)
- rrd_stats_dimension_add(st, nfsd_proc_values[i].name, NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, nfsd_proc_values[i].name, NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
for(i = 0; nfsd_proc_values[i].present4 ; i++)
- rrd_stats_dimension_set(st, nfsd_proc_values[i].name, nfsd_proc_values[i].proc4);
+ rrddim_set(st, nfsd_proc_values[i].name, nfsd_proc_values[i].proc4);
- rrd_stats_done(st);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_proc4ops == 2) {
unsigned int i;
- st = rrd_stats_find_bytype("nfsd", "proc4ops");
+ st = rrdset_find_bytype("nfsd", "proc4ops");
if(!st) {
- st = rrd_stats_create("nfsd", "proc4ops", NULL, "nfsd", "NFS v4 Operations", "operations/s", 5012, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create("nfsd", "proc4ops", NULL, "nfsd", "NFS v4 Operations", "operations/s", 5012, update_every, RRDSET_TYPE_STACKED);
for(i = 0; nfsd4_ops_values[i].present ; i++)
- rrd_stats_dimension_add(st, nfsd4_ops_values[i].name, NULL, 1, update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, nfsd4_ops_values[i].name, NULL, 1, update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
for(i = 0; nfsd4_ops_values[i].present ; i++)
- rrd_stats_dimension_set(st, nfsd4_ops_values[i].name, nfsd4_ops_values[i].value);
+ rrddim_set(st, nfsd4_ops_values[i].name, nfsd4_ops_values[i].value);
- rrd_stats_done(st);
+ rrdset_done(st);
}
return 0;
uint32_t lines = procfile_lines(ff), l;
uint32_t words;
- RRD_STATS *st;
+ RRDSET *st;
for(l = 0; l < lines ;l++) {
if(strcmp(procfile_lineword(ff, l, 0), "Ip") == 0) {
// --------------------------------------------------------------------
if(do_ip_packets) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".packets");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".packets");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "packets", NULL, RRD_TYPE_NET_SNMP, "IPv4 Packets", "packets/s", 3000, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "packets", NULL, RRD_TYPE_NET_SNMP, "IPv4 Packets", "packets/s", 3000, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "forwarded", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "forwarded", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "sent", OutRequests);
- rrd_stats_dimension_set(st, "received", InReceives);
- rrd_stats_dimension_set(st, "forwarded", ForwDatagrams);
- rrd_stats_done(st);
+ rrddim_set(st, "sent", OutRequests);
+ rrddim_set(st, "received", InReceives);
+ rrddim_set(st, "forwarded", ForwDatagrams);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ip_fragsout) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".fragsout");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".fragsout");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "fragsout", NULL, RRD_TYPE_NET_SNMP, "IPv4 Fragments Sent", "packets/s", 3010, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "fragsout", NULL, RRD_TYPE_NET_SNMP, "IPv4 Fragments Sent", "packets/s", 3010, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "ok", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "failed", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "all", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "ok", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "failed", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "all", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "ok", FragOKs);
- rrd_stats_dimension_set(st, "failed", FragFails);
- rrd_stats_dimension_set(st, "all", FragCreates);
- rrd_stats_done(st);
+ rrddim_set(st, "ok", FragOKs);
+ rrddim_set(st, "failed", FragFails);
+ rrddim_set(st, "all", FragCreates);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ip_fragsin) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".fragsin");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".fragsin");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "fragsin", NULL, RRD_TYPE_NET_SNMP, "IPv4 Fragments Reassembly", "packets/s", 3011, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "fragsin", NULL, RRD_TYPE_NET_SNMP, "IPv4 Fragments Reassembly", "packets/s", 3011, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "ok", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "failed", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "all", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "ok", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "failed", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "all", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "ok", ReasmOKs);
- rrd_stats_dimension_set(st, "failed", ReasmFails);
- rrd_stats_dimension_set(st, "all", ReasmReqds);
- rrd_stats_done(st);
+ rrddim_set(st, "ok", ReasmOKs);
+ rrddim_set(st, "failed", ReasmFails);
+ rrddim_set(st, "all", ReasmReqds);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_ip_errors) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".errors");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".errors");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "errors", NULL, RRD_TYPE_NET_SNMP, "IPv4 Errors", "packets/s", 3002, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "errors", NULL, RRD_TYPE_NET_SNMP, "IPv4 Errors", "packets/s", 3002, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "InDiscards", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "OutDiscards", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "InDiscards", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "OutDiscards", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
- rrd_stats_dimension_add(st, "InHdrErrors", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "InAddrErrors", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "InUnknownProtos", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "InHdrErrors", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "InAddrErrors", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "InUnknownProtos", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
- rrd_stats_dimension_add(st, "OutNoRoutes", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "OutNoRoutes", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
-
- rrd_stats_dimension_set(st, "InDiscards", InDiscards);
- rrd_stats_dimension_set(st, "OutDiscards", OutDiscards);
- rrd_stats_dimension_set(st, "InHdrErrors", InHdrErrors);
- rrd_stats_dimension_set(st, "InAddrErrors", InAddrErrors);
- rrd_stats_dimension_set(st, "InUnknownProtos", InUnknownProtos);
- rrd_stats_dimension_set(st, "OutNoRoutes", OutNoRoutes);
- rrd_stats_done(st);
+ else rrdset_next(st);
+
+ rrddim_set(st, "InDiscards", InDiscards);
+ rrddim_set(st, "OutDiscards", OutDiscards);
+ rrddim_set(st, "InHdrErrors", InHdrErrors);
+ rrddim_set(st, "InAddrErrors", InAddrErrors);
+ rrddim_set(st, "InUnknownProtos", InUnknownProtos);
+ rrddim_set(st, "OutNoRoutes", OutNoRoutes);
+ rrdset_done(st);
}
}
else if(strcmp(procfile_lineword(ff, l, 0), "Tcp") == 0) {
// see http://net-snmp.sourceforge.net/docs/mibs/tcp.html
if(do_tcp_sockets) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".tcpsock");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".tcpsock");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "tcpsock", NULL, "tcp", "IPv4 TCP Connections", "active connections", 2500, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "tcpsock", NULL, "tcp", "IPv4 TCP Connections", "active connections", 2500, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "connections", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "connections", NULL, 1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "connections", CurrEstab);
- rrd_stats_done(st);
+ rrddim_set(st, "connections", CurrEstab);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcp_packets) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".tcppackets");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".tcppackets");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "tcppackets", NULL, "tcp", "IPv4 TCP Packets", "packets/s", 2600, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "tcppackets", NULL, "tcp", "IPv4 TCP Packets", "packets/s", 2600, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", InSegs);
- rrd_stats_dimension_set(st, "sent", OutSegs);
- rrd_stats_done(st);
+ rrddim_set(st, "received", InSegs);
+ rrddim_set(st, "sent", OutSegs);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcp_errors) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".tcperrors");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".tcperrors");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "tcperrors", NULL, "tcp", "IPv4 TCP Errors", "packets/s", 2700, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "tcperrors", NULL, "tcp", "IPv4 TCP Errors", "packets/s", 2700, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "InErrs", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "RetransSegs", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "InErrs", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "RetransSegs", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "InErrs", InErrs);
- rrd_stats_dimension_set(st, "RetransSegs", RetransSegs);
- rrd_stats_done(st);
+ rrddim_set(st, "InErrs", InErrs);
+ rrddim_set(st, "RetransSegs", RetransSegs);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_tcp_handshake) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".tcphandshake");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".tcphandshake");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "tcphandshake", NULL, "tcp", "IPv4 TCP Handshake Issues", "events/s", 2900, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "tcphandshake", NULL, "tcp", "IPv4 TCP Handshake Issues", "events/s", 2900, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "EstabResets", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "OutRsts", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "ActiveOpens", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "PassiveOpens", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "AttemptFails", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "EstabResets", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "OutRsts", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "ActiveOpens", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "PassiveOpens", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "AttemptFails", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
-
- rrd_stats_dimension_set(st, "EstabResets", EstabResets);
- rrd_stats_dimension_set(st, "OutRsts", OutRsts);
- rrd_stats_dimension_set(st, "ActiveOpens", ActiveOpens);
- rrd_stats_dimension_set(st, "PassiveOpens", PassiveOpens);
- rrd_stats_dimension_set(st, "AttemptFails", AttemptFails);
- rrd_stats_done(st);
+ else rrdset_next(st);
+
+ rrddim_set(st, "EstabResets", EstabResets);
+ rrddim_set(st, "OutRsts", OutRsts);
+ rrddim_set(st, "ActiveOpens", ActiveOpens);
+ rrddim_set(st, "PassiveOpens", PassiveOpens);
+ rrddim_set(st, "AttemptFails", AttemptFails);
+ rrdset_done(st);
}
}
else if(strcmp(procfile_lineword(ff, l, 0), "Udp") == 0) {
// see http://net-snmp.sourceforge.net/docs/mibs/udp.html
if(do_udp_packets) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".udppackets");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".udppackets");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "udppackets", NULL, "udp", "IPv4 UDP Packets", "packets/s", 2601, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "udppackets", NULL, "udp", "IPv4 UDP Packets", "packets/s", 2601, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "received", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "sent", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "received", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "sent", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "received", InDatagrams);
- rrd_stats_dimension_set(st, "sent", OutDatagrams);
- rrd_stats_done(st);
+ rrddim_set(st, "received", InDatagrams);
+ rrddim_set(st, "sent", OutDatagrams);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_udp_errors) {
- st = rrd_stats_find(RRD_TYPE_NET_SNMP ".udperrors");
+ st = rrdset_find(RRD_TYPE_NET_SNMP ".udperrors");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_SNMP, "udperrors", NULL, "udp", "IPv4 UDP Errors", "events/s", 2701, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_SNMP, "udperrors", NULL, "udp", "IPv4 UDP Errors", "events/s", 2701, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "RcvbufErrors", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "SndbufErrors", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "InErrors", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "NoPorts", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "RcvbufErrors", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "SndbufErrors", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "InErrors", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "NoPorts", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "InErrors", InErrors);
- rrd_stats_dimension_set(st, "NoPorts", NoPorts);
- rrd_stats_dimension_set(st, "RcvbufErrors", RcvbufErrors);
- rrd_stats_dimension_set(st, "SndbufErrors", SndbufErrors);
- rrd_stats_done(st);
+ rrddim_set(st, "InErrors", InErrors);
+ rrddim_set(st, "NoPorts", NoPorts);
+ rrddim_set(st, "RcvbufErrors", RcvbufErrors);
+ rrddim_set(st, "SndbufErrors", SndbufErrors);
+ rrdset_done(st);
}
}
}
asearch_restart += tsearch_restart; // conntrack.search
}
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_sockets) {
- st = rrd_stats_find(RRD_TYPE_NET_STAT_CONNTRACK ".sockets");
+ st = rrdset_find(RRD_TYPE_NET_STAT_CONNTRACK ".sockets");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_STAT_CONNTRACK, "sockets", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connections", "active connections", 1000, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_STAT_CONNTRACK, "sockets", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connections", "active connections", 1000, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "connections", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "connections", NULL, 1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "connections", aentries);
- rrd_stats_done(st);
+ rrddim_set(st, "connections", aentries);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_new) {
- st = rrd_stats_find(RRD_TYPE_NET_STAT_CONNTRACK ".new");
+ st = rrdset_find(RRD_TYPE_NET_STAT_CONNTRACK ".new");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_STAT_CONNTRACK, "new", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter New Connections", "connections/s", 1001, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_STAT_CONNTRACK, "new", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter New Connections", "connections/s", 1001, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "new", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "ignore", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "invalid", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "new", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "ignore", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "invalid", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "new", anew);
- rrd_stats_dimension_set(st, "ignore", aignore);
- rrd_stats_dimension_set(st, "invalid", ainvalid);
- rrd_stats_done(st);
+ rrddim_set(st, "new", anew);
+ rrddim_set(st, "ignore", aignore);
+ rrddim_set(st, "invalid", ainvalid);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_changes) {
- st = rrd_stats_find(RRD_TYPE_NET_STAT_CONNTRACK ".changes");
+ st = rrdset_find(RRD_TYPE_NET_STAT_CONNTRACK ".changes");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_STAT_CONNTRACK, "changes", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connection Changes", "changes/s", 1002, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_STAT_CONNTRACK, "changes", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connection Changes", "changes/s", 1002, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "inserted", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "deleted", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "delete_list", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "inserted", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "deleted", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "delete_list", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "inserted", ainsert);
- rrd_stats_dimension_set(st, "deleted", adelete);
- rrd_stats_dimension_set(st, "delete_list", adelete_list);
- rrd_stats_done(st);
+ rrddim_set(st, "inserted", ainsert);
+ rrddim_set(st, "deleted", adelete);
+ rrddim_set(st, "delete_list", adelete_list);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_expect) {
- st = rrd_stats_find(RRD_TYPE_NET_STAT_CONNTRACK ".expect");
+ st = rrdset_find(RRD_TYPE_NET_STAT_CONNTRACK ".expect");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_STAT_CONNTRACK, "expect", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connection Expectations", "expectations/s", 1003, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_STAT_CONNTRACK, "expect", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connection Expectations", "expectations/s", 1003, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "created", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "deleted", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "new", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "created", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "deleted", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "new", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "created", aexpect_create);
- rrd_stats_dimension_set(st, "deleted", aexpect_delete);
- rrd_stats_dimension_set(st, "new", aexpect_new);
- rrd_stats_done(st);
+ rrddim_set(st, "created", aexpect_create);
+ rrddim_set(st, "deleted", aexpect_delete);
+ rrddim_set(st, "new", aexpect_new);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_search) {
- st = rrd_stats_find(RRD_TYPE_NET_STAT_CONNTRACK ".search");
+ st = rrdset_find(RRD_TYPE_NET_STAT_CONNTRACK ".search");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_STAT_CONNTRACK, "search", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connection Searches", "searches/s", 1010, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_STAT_CONNTRACK, "search", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Connection Searches", "searches/s", 1010, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "searched", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "restarted", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "found", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "searched", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "restarted", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "found", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "searched", asearched);
- rrd_stats_dimension_set(st, "restarted", asearch_restart);
- rrd_stats_dimension_set(st, "found", afound);
- rrd_stats_done(st);
+ rrddim_set(st, "searched", asearched);
+ rrddim_set(st, "restarted", asearch_restart);
+ rrddim_set(st, "found", afound);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_errors) {
- st = rrd_stats_find(RRD_TYPE_NET_STAT_CONNTRACK ".errors");
+ st = rrdset_find(RRD_TYPE_NET_STAT_CONNTRACK ".errors");
if(!st) {
- st = rrd_stats_create(RRD_TYPE_NET_STAT_CONNTRACK, "errors", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Errors", "events/s", 1005, update_every, CHART_TYPE_LINE);
+ st = rrdset_create(RRD_TYPE_NET_STAT_CONNTRACK, "errors", NULL, RRD_TYPE_NET_STAT_CONNTRACK, "Netfilter Errors", "events/s", 1005, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "icmp_error", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "insert_failed", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "drop", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "early_drop", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "icmp_error", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "insert_failed", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "drop", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "early_drop", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "icmp_error", aicmp_error);
- rrd_stats_dimension_set(st, "insert_failed", ainsert_failed);
- rrd_stats_dimension_set(st, "drop", adrop);
- rrd_stats_dimension_set(st, "early_drop", aearly_drop);
- rrd_stats_done(st);
+ rrddim_set(st, "icmp_error", aicmp_error);
+ rrddim_set(st, "insert_failed", ainsert_failed);
+ rrddim_set(st, "drop", adrop);
+ rrddim_set(st, "early_drop", aearly_drop);
+ rrdset_done(st);
}
return 0;
uint32_t words;
unsigned long long processes = 0, running = 0 , blocked = 0;
- RRD_STATS *st;
+ RRDSET *st;
for(l = 0; l < lines ;l++) {
if(strncmp(procfile_lineword(ff, l, 0), "cpu", 3) == 0) {
}
if((isthistotal && do_cpu) || (!isthistotal && do_cpu_cores)) {
- st = rrd_stats_find_bytype(type, id);
+ st = rrdset_find_bytype(type, id);
if(!st) {
- st = rrd_stats_create(type, id, NULL, "cpu", title, "percentage", priority, update_every, CHART_TYPE_STACKED);
+ st = rrdset_create(type, id, NULL, "cpu", title, "percentage", priority, update_every, RRDSET_TYPE_STACKED);
long multiplier = 1;
long divisor = 1; // sysconf(_SC_CLK_TCK);
- rrd_stats_dimension_add(st, "guest_nice", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "guest", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "steal", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "softirq", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "irq", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "user", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "system", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "nice", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_add(st, "iowait", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
-
- rrd_stats_dimension_add(st, "idle", NULL, multiplier, divisor, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
- rrd_stats_dimension_hide(st, "idle");
+ rrddim_add(st, "guest_nice", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "guest", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "steal", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "softirq", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "irq", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "user", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "system", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "nice", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_add(st, "iowait", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+
+ rrddim_add(st, "idle", NULL, multiplier, divisor, RRDDIM_PCENT_OVER_DIFF_TOTAL);
+ rrddim_hide(st, "idle");
}
- else rrd_stats_next(st);
-
- rrd_stats_dimension_set(st, "user", user);
- rrd_stats_dimension_set(st, "nice", nice);
- rrd_stats_dimension_set(st, "system", system);
- rrd_stats_dimension_set(st, "idle", idle);
- rrd_stats_dimension_set(st, "iowait", iowait);
- rrd_stats_dimension_set(st, "irq", irq);
- rrd_stats_dimension_set(st, "softirq", softirq);
- rrd_stats_dimension_set(st, "steal", steal);
- rrd_stats_dimension_set(st, "guest", guest);
- rrd_stats_dimension_set(st, "guest_nice", guest_nice);
- rrd_stats_done(st);
+ else rrdset_next(st);
+
+ rrddim_set(st, "user", user);
+ rrddim_set(st, "nice", nice);
+ rrddim_set(st, "system", system);
+ rrddim_set(st, "idle", idle);
+ rrddim_set(st, "iowait", iowait);
+ rrddim_set(st, "irq", irq);
+ rrddim_set(st, "softirq", softirq);
+ rrddim_set(st, "steal", steal);
+ rrddim_set(st, "guest", guest);
+ rrddim_set(st, "guest_nice", guest_nice);
+ rrdset_done(st);
}
}
else if(strcmp(procfile_lineword(ff, l, 0), "intr") == 0) {
// --------------------------------------------------------------------
if(do_interrupts) {
- st = rrd_stats_find_bytype("system", "intr");
+ st = rrdset_find_bytype("system", "intr");
if(!st) {
- st = rrd_stats_create("system", "intr", NULL, "cpu", "CPU Interrupts", "interrupts/s", 900, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("system", "intr", NULL, "cpu", "CPU Interrupts", "interrupts/s", 900, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "interrupts", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "interrupts", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "interrupts", value);
- rrd_stats_done(st);
+ rrddim_set(st, "interrupts", value);
+ rrdset_done(st);
}
}
else if(strcmp(procfile_lineword(ff, l, 0), "ctxt") == 0) {
// --------------------------------------------------------------------
if(do_context) {
- st = rrd_stats_find_bytype("system", "ctxt");
+ st = rrdset_find_bytype("system", "ctxt");
if(!st) {
- st = rrd_stats_create("system", "ctxt", NULL, "cpu", "CPU Context Switches", "context switches/s", 800, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("system", "ctxt", NULL, "cpu", "CPU Context Switches", "context switches/s", 800, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "switches", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "switches", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "switches", value);
- rrd_stats_done(st);
+ rrddim_set(st, "switches", value);
+ rrdset_done(st);
}
}
else if(!processes && strcmp(procfile_lineword(ff, l, 0), "processes") == 0) {
// --------------------------------------------------------------------
if(do_forks) {
- st = rrd_stats_find_bytype("system", "forks");
+ st = rrdset_find_bytype("system", "forks");
if(!st) {
- st = rrd_stats_create("system", "forks", NULL, "cpu", "New Processes", "processes/s", 700, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("system", "forks", NULL, "cpu", "New Processes", "processes/s", 700, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "started", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "started", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "started", processes);
- rrd_stats_done(st);
+ rrddim_set(st, "started", processes);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_processes) {
- st = rrd_stats_find_bytype("system", "processes");
+ st = rrdset_find_bytype("system", "processes");
if(!st) {
- st = rrd_stats_create("system", "processes", NULL, "cpu", "Processes", "processes", 600, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("system", "processes", NULL, "cpu", "Processes", "processes", 600, update_every, RRDSET_TYPE_LINE);
- rrd_stats_dimension_add(st, "running", NULL, 1, 1, RRD_DIMENSION_ABSOLUTE);
- rrd_stats_dimension_add(st, "blocked", NULL, -1, 1, RRD_DIMENSION_ABSOLUTE);
+ rrddim_add(st, "running", NULL, 1, 1, RRDDIM_ABSOLUTE);
+ rrddim_add(st, "blocked", NULL, -1, 1, RRDDIM_ABSOLUTE);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "running", running);
- rrd_stats_dimension_set(st, "blocked", blocked);
- rrd_stats_done(st);
+ rrddim_set(st, "running", running);
+ rrddim_set(st, "blocked", blocked);
+ rrdset_done(st);
}
return 0;
else if(!thp_split && strcmp(name, "thp_split") == 0) thp_split = value;
}
- RRD_STATS *st;
+ RRDSET *st;
// --------------------------------------------------------------------
if(do_swapio) {
- st = rrd_stats_find("system.swapio");
+ st = rrdset_find("system.swapio");
if(!st) {
- st = rrd_stats_create("system", "swapio", NULL, "mem", "Swap I/O", "kilobytes/s", 250, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("system", "swapio", NULL, "mem", "Swap I/O", "kilobytes/s", 250, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "in", NULL, sysconf(_SC_PAGESIZE), 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "out", NULL, -sysconf(_SC_PAGESIZE), 1024 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "in", NULL, sysconf(_SC_PAGESIZE), 1024 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "out", NULL, -sysconf(_SC_PAGESIZE), 1024 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "in", pswpin);
- rrd_stats_dimension_set(st, "out", pswpout);
- rrd_stats_done(st);
+ rrddim_set(st, "in", pswpin);
+ rrddim_set(st, "out", pswpout);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_io) {
- st = rrd_stats_find("system.io");
+ st = rrdset_find("system.io");
if(!st) {
- st = rrd_stats_create("system", "io", NULL, "disk", "Disk I/O", "kilobytes/s", 150, update_every, CHART_TYPE_AREA);
+ st = rrdset_create("system", "io", NULL, "disk", "Disk I/O", "kilobytes/s", 150, update_every, RRDSET_TYPE_AREA);
- rrd_stats_dimension_add(st, "in", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "out", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "in", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "out", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "in", pgpgin);
- rrd_stats_dimension_set(st, "out", pgpgout);
- rrd_stats_done(st);
+ rrddim_set(st, "in", pgpgin);
+ rrddim_set(st, "out", pgpgout);
+ rrdset_done(st);
}
// --------------------------------------------------------------------
if(do_pgfaults) {
- st = rrd_stats_find("system.pgfaults");
+ st = rrdset_find("system.pgfaults");
if(!st) {
- st = rrd_stats_create("system", "pgfaults", NULL, "mem", "Memory Page Faults", "page faults/s", 500, update_every, CHART_TYPE_LINE);
+ st = rrdset_create("system", "pgfaults", NULL, "mem", "Memory Page Faults", "page faults/s", 500, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
- rrd_stats_dimension_add(st, "minor", NULL, 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- rrd_stats_dimension_add(st, "major", NULL, -1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
+ rrddim_add(st, "minor", NULL, 1, 1 * update_every, RRDDIM_INCREMENTAL);
+ rrddim_add(st, "major", NULL, -1, 1 * update_every, RRDDIM_INCREMENTAL);
}
- else rrd_stats_next(st);
+ else rrdset_next(st);
- rrd_stats_dimension_set(st, "minor", pgfault);
- rrd_stats_dimension_set(st, "major", pgmajfault);
- rrd_stats_done(st);
+ rrddim_set(st, "minor", pgfault);
+ rrddim_set(st, "major", pgmajfault);
+ rrdset_done(st);
}
return 0;
#ifndef NETDATA_PROCFILE_H
#define NETDATA_PROCFILE_H 1
-// if enabled, procfile will output a lot of debug info
-extern int pfdebug;
-
// ----------------------------------------------------------------------------
// An array of words
#include "rrd.h"
-int update_every = UPDATE_EVERY;
-int save_history = HISTORY;
+// ----------------------------------------------------------------------------
+// globals
+
+int rrd_update_every = UPDATE_EVERY;
+int rrd_default_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
+
+RRDSET *rrdset_root = NULL;
+pthread_rwlock_t rrdset_root_rwlock = PTHREAD_RWLOCK_INITIALIZER;
+
+int rrd_memory_mode = RRD_MEMORY_MODE_SAVE;
+
+
+// ----------------------------------------------------------------------------
+// RRDSET index
+
+static int rrdset_iterator(avl *a) { if(a) {}; return 0; }
+
+static int rrdset_compare(void* a, void* b) {
+ if(((RRDSET *)a)->hash < ((RRDSET *)b)->hash) return -1;
+ else if(((RRDSET *)a)->hash > ((RRDSET *)b)->hash) return 1;
+ else return strcmp(((RRDSET *)a)->id, ((RRDSET *)b)->id);
+}
+
+avl_tree rrdset_root_index = {
+ NULL,
+ rrdset_compare
+};
+
+#define rrdset_index_add(st) avl_insert(&rrdset_root_index, (avl *)(st))
+#define rrdset_index_del(st) avl_remove(&rrdset_root_index, (avl *)(st))
+
+static RRDSET *rrdset_index_find(const char *id, unsigned long hash) {
+ RRDSET *result = NULL, tmp;
+ strncpy(tmp.id, id, RRD_ID_LENGTH_MAX);
+ tmp.id[RRD_ID_LENGTH_MAX] = '\0';
+ tmp.hash = (hash)?hash:simple_hash(tmp.id);
+
+ avl_search(&(rrdset_root_index), (avl *)&tmp, rrdset_iterator, (avl **)&result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// RRDDIM index
+
+static int rrddim_iterator(avl *a) { if(a) {}; return 0; }
+
+static int rrddim_compare(void* a, void* b) {
+ if(((RRDDIM *)a)->hash < ((RRDDIM *)b)->hash) return -1;
+ else if(((RRDDIM *)a)->hash > ((RRDDIM *)b)->hash) return 1;
+ else return strcmp(((RRDDIM *)a)->id, ((RRDDIM *)b)->id);
+}
+
+#define rrddim_index_add(st, rd) avl_insert(&((st)->dimensions_index), (avl *)(rd))
+#define rrddim_index_del(st,rd ) avl_remove(&((st)->dimensions_index), (avl *)(rd))
+
+static RRDDIM *rrddim_index_find(RRDSET *st, const char *id, unsigned long hash) {
+ RRDDIM *result = NULL, tmp;
+ tmp.hash = (hash)?hash:simple_hash(id);
+ strncpy(tmp.id, id, RRD_ID_LENGTH_MAX);
+ tmp.id[RRD_ID_LENGTH_MAX] = '\0';
+ tmp.hash = (hash)?hash:simple_hash(tmp.id);
+
+ avl_search(&(st->dimensions_index), (avl *)&tmp, rrddim_iterator, (avl **)&result);
+ return result;
+}
// ----------------------------------------------------------------------------
// chart types
-int chart_type_id(const char *name)
+int rrdset_type_id(const char *name)
{
- if(strcmp(name, CHART_TYPE_AREA_NAME) == 0) return CHART_TYPE_AREA;
- if(strcmp(name, CHART_TYPE_STACKED_NAME) == 0) return CHART_TYPE_STACKED;
- if(strcmp(name, CHART_TYPE_LINE_NAME) == 0) return CHART_TYPE_LINE;
- return CHART_TYPE_LINE;
+ if(strcmp(name, RRDSET_TYPE_AREA_NAME) == 0) return RRDSET_TYPE_AREA;
+ if(strcmp(name, RRDSET_TYPE_STACKED_NAME) == 0) return RRDSET_TYPE_STACKED;
+ if(strcmp(name, RRDSET_TYPE_LINE_NAME) == 0) return RRDSET_TYPE_LINE;
+ return RRDSET_TYPE_LINE;
}
-const char *chart_type_name(int chart_type)
+const char *rrdset_type_name(int chart_type)
{
- static char line[] = CHART_TYPE_LINE_NAME;
- static char area[] = CHART_TYPE_AREA_NAME;
- static char stacked[] = CHART_TYPE_STACKED_NAME;
+ static char line[] = RRDSET_TYPE_LINE_NAME;
+ static char area[] = RRDSET_TYPE_AREA_NAME;
+ static char stacked[] = RRDSET_TYPE_STACKED_NAME;
switch(chart_type) {
- case CHART_TYPE_LINE:
+ case RRDSET_TYPE_LINE:
return line;
- case CHART_TYPE_AREA:
+ case RRDSET_TYPE_AREA:
return area;
- case CHART_TYPE_STACKED:
+ case RRDSET_TYPE_STACKED:
return stacked;
}
return line;
}
// ----------------------------------------------------------------------------
-// mmap() wrapper
+// load / save
-int memory_mode = NETDATA_MEMORY_MODE_SAVE;
-
-const char *memory_mode_name(int id)
+const char *rrd_memory_mode_name(int id)
{
- static const char ram[] = NETDATA_MEMORY_MODE_RAM_NAME;
- static const char map[] = NETDATA_MEMORY_MODE_MAP_NAME;
- static const char save[] = NETDATA_MEMORY_MODE_SAVE_NAME;
+ static const char ram[] = RRD_MEMORY_MODE_RAM_NAME;
+ static const char map[] = RRD_MEMORY_MODE_MAP_NAME;
+ static const char save[] = RRD_MEMORY_MODE_SAVE_NAME;
switch(id) {
- case NETDATA_MEMORY_MODE_RAM:
+ case RRD_MEMORY_MODE_RAM:
return ram;
- case NETDATA_MEMORY_MODE_MAP:
+ case RRD_MEMORY_MODE_MAP:
return map;
- case NETDATA_MEMORY_MODE_SAVE:
+ case RRD_MEMORY_MODE_SAVE:
default:
return save;
}
return save;
}
-int memory_mode_id(const char *name)
+int rrd_memory_mode_id(const char *name)
{
- if(!strcmp(name, NETDATA_MEMORY_MODE_RAM_NAME))
- return NETDATA_MEMORY_MODE_RAM;
- else if(!strcmp(name, NETDATA_MEMORY_MODE_MAP_NAME))
- return NETDATA_MEMORY_MODE_MAP;
+ if(!strcmp(name, RRD_MEMORY_MODE_RAM_NAME))
+ return RRD_MEMORY_MODE_RAM;
+ else if(!strcmp(name, RRD_MEMORY_MODE_MAP_NAME))
+ return RRD_MEMORY_MODE_MAP;
- return NETDATA_MEMORY_MODE_SAVE;
+ return RRD_MEMORY_MODE_SAVE;
}
// ----------------------------------------------------------------------------
// algorithms types
-int algorithm_id(const char *name)
+int rrddim_algorithm_id(const char *name)
{
- if(strcmp(name, RRD_DIMENSION_ABSOLUTE_NAME) == 0) return RRD_DIMENSION_ABSOLUTE;
- if(strcmp(name, RRD_DIMENSION_INCREMENTAL_NAME) == 0) return RRD_DIMENSION_INCREMENTAL;
- if(strcmp(name, RRD_DIMENSION_PCENT_OVER_ROW_TOTAL_NAME) == 0) return RRD_DIMENSION_PCENT_OVER_ROW_TOTAL;
- if(strcmp(name, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL_NAME) == 0) return RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL;
- return RRD_DIMENSION_ABSOLUTE;
+ if(strcmp(name, RRDDIM_ABSOLUTE_NAME) == 0) return RRDDIM_ABSOLUTE;
+ if(strcmp(name, RRDDIM_INCREMENTAL_NAME) == 0) return RRDDIM_INCREMENTAL;
+ if(strcmp(name, RRDDIM_PCENT_OVER_ROW_TOTAL_NAME) == 0) return RRDDIM_PCENT_OVER_ROW_TOTAL;
+ if(strcmp(name, RRDDIM_PCENT_OVER_DIFF_TOTAL_NAME) == 0) return RRDDIM_PCENT_OVER_DIFF_TOTAL;
+ return RRDDIM_ABSOLUTE;
}
-const char *algorithm_name(int chart_type)
+const char *rrddim_algorithm_name(int chart_type)
{
- static char absolute[] = RRD_DIMENSION_ABSOLUTE_NAME;
- static char incremental[] = RRD_DIMENSION_INCREMENTAL_NAME;
- static char percentage_of_absolute_row[] = RRD_DIMENSION_PCENT_OVER_ROW_TOTAL_NAME;
- static char percentage_of_incremental_row[] = RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL_NAME;
+ static char absolute[] = RRDDIM_ABSOLUTE_NAME;
+ static char incremental[] = RRDDIM_INCREMENTAL_NAME;
+ static char percentage_of_absolute_row[] = RRDDIM_PCENT_OVER_ROW_TOTAL_NAME;
+ static char percentage_of_incremental_row[] = RRDDIM_PCENT_OVER_DIFF_TOTAL_NAME;
switch(chart_type) {
- case RRD_DIMENSION_ABSOLUTE:
+ case RRDDIM_ABSOLUTE:
return absolute;
- case RRD_DIMENSION_INCREMENTAL:
+ case RRDDIM_INCREMENTAL:
return incremental;
- case RRD_DIMENSION_PCENT_OVER_ROW_TOTAL:
+ case RRDDIM_PCENT_OVER_ROW_TOTAL:
return percentage_of_absolute_row;
- case RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_PCENT_OVER_DIFF_TOTAL:
return percentage_of_incremental_row;
}
return absolute;
}
-RRD_STATS *root = NULL;
-pthread_rwlock_t root_rwlock = PTHREAD_RWLOCK_INITIALIZER;
+// ----------------------------------------------------------------------------
+// chart names
-char *rrd_stats_strncpy_name(char *to, const char *from, int length)
+char *rrdset_strncpy_name(char *to, const char *from, int length)
{
int i;
for(i = 0; i < length && from[i] ;i++) {
return to;
}
-void rrd_stats_set_name(RRD_STATS *st, const char *name)
+void rrdset_set_name(RRDSET *st, const char *name)
{
char b[CONFIG_MAX_VALUE + 1];
- char n[RRD_STATS_NAME_MAX + 1];
+ char n[RRD_ID_LENGTH_MAX + 1];
- snprintf(n, RRD_STATS_NAME_MAX, "%s.%s", st->type, name);
- rrd_stats_strncpy_name(b, n, CONFIG_MAX_VALUE);
+ snprintf(n, RRD_ID_LENGTH_MAX, "%s.%s", st->type, name);
+ rrdset_strncpy_name(b, n, CONFIG_MAX_VALUE);
st->name = config_get(st->id, "name", b);
st->hash_name = simple_hash(st->name);
}
-char *rrd_stats_cache_dir(const char *id)
+// ----------------------------------------------------------------------------
+// cache directory
+
+char *rrdset_cache_dir(const char *id)
{
char *ret = NULL;
char b[FILENAME_MAX + 1];
char n[FILENAME_MAX + 1];
- rrd_stats_strncpy_name(b, id, FILENAME_MAX);
+ rrdset_strncpy_name(b, id, FILENAME_MAX);
snprintf(n, FILENAME_MAX, "%s/%s", cache_dir, b);
ret = config_get(id, "database directory", n);
- if(memory_mode == NETDATA_MEMORY_MODE_MAP || memory_mode == NETDATA_MEMORY_MODE_SAVE) {
+ if(rrd_memory_mode == RRD_MEMORY_MODE_MAP || rrd_memory_mode == RRD_MEMORY_MODE_SAVE) {
int r = mkdir(ret, 0775);
if(r != 0 && errno != EEXIST)
error("Cannot create directory '%s'", ret);
return ret;
}
-void rrd_stats_reset(RRD_STATS *st)
+// ----------------------------------------------------------------------------
+// core functions
+
+void rrdset_reset(RRDSET *st)
{
st->last_collected_time.tv_sec = 0;
st->last_collected_time.tv_usec = 0;
st->counter = 0;
st->counter_done = 0;
- RRD_DIMENSION *rd;
+ RRDDIM *rd;
for(rd = st->dimensions; rd ; rd = rd->next) {
rd->last_collected_time.tv_sec = 0;
rd->last_collected_time.tv_usec = 0;
}
}
-RRD_STATS *rrd_stats_create(const char *type, const char *id, const char *name, const char *family, const char *title, const char *units, long priority, int update_every, int chart_type)
+RRDSET *rrdset_create(const char *type, const char *id, const char *name, const char *family, const char *title, const char *units, long priority, int update_every, int chart_type)
{
if(!id || !id[0]) {
fatal("Cannot create rrd stats without an id.");
return NULL;
}
- char fullid[RRD_STATS_NAME_MAX + 1];
+ char fullid[RRD_ID_LENGTH_MAX + 1];
char fullfilename[FILENAME_MAX + 1];
- RRD_STATS *st = NULL;
+ RRDSET *st = NULL;
- snprintf(fullid, RRD_STATS_NAME_MAX, "%s.%s", type, id);
+ snprintf(fullid, RRD_ID_LENGTH_MAX, "%s.%s", type, id);
- long entries = config_get_number(fullid, "history", save_history);
+ long entries = config_get_number(fullid, "history", rrd_default_history_entries);
if(entries < 5) entries = config_set_number(fullid, "history", 5);
- if(entries > HISTORY_MAX) entries = config_set_number(fullid, "history", HISTORY_MAX);
+ if(entries > RRD_HISTORY_ENTRIES_MAX) entries = config_set_number(fullid, "history", RRD_HISTORY_ENTRIES_MAX);
int enabled = config_get_boolean(fullid, "enabled", 1);
if(!enabled) entries = 5;
- unsigned long size = sizeof(RRD_STATS);
- char *cache_dir = rrd_stats_cache_dir(fullid);
+ unsigned long size = sizeof(RRDSET);
+ char *cache_dir = rrdset_cache_dir(fullid);
debug(D_RRD_CALLS, "Creating RRD_STATS for '%s.%s'.", type, id);
snprintf(fullfilename, FILENAME_MAX, "%s/main.db", cache_dir);
- if(memory_mode != NETDATA_MEMORY_MODE_RAM) st = (RRD_STATS *)mymmap(fullfilename, size, ((memory_mode == NETDATA_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE));
+ if(rrd_memory_mode != RRD_MEMORY_MODE_RAM) st = (RRDSET *)mymmap(fullfilename, size, ((rrd_memory_mode == RRD_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE));
if(st) {
- if(strcmp(st->magic, RRD_STATS_MAGIC) != 0) {
+ if(strcmp(st->magic, RRDSET_MAGIC) != 0) {
errno = 0;
info("Initializing file %s.", fullfilename);
bzero(st, size);
st->units = NULL;
st->dimensions = NULL;
st->next = NULL;
- st->mapped = memory_mode;
+ st->mapped = rrd_memory_mode;
}
else {
st = calloc(1, size);
fatal("Cannot allocate memory for RRD_STATS %s.%s", type, id);
return NULL;
}
- st->mapped = NETDATA_MEMORY_MODE_RAM;
+ st->mapped = RRD_MEMORY_MODE_RAM;
}
st->memsize = size;
st->entries = entries;
st->update_every = update_every;
- strcpy(st->cache_file, fullfilename);
- strcpy(st->magic, RRD_STATS_MAGIC);
+ strcpy(st->cache_filename, fullfilename);
+ strcpy(st->magic, RRDSET_MAGIC);
strcpy(st->id, fullid);
st->hash = simple_hash(st->id);
st->family = config_get(st->id, "family", family?family:st->id);
st->units = config_get(st->id, "units", units?units:"");
st->type = config_get(st->id, "type", type);
- st->chart_type = chart_type_id(config_get(st->id, "chart type", chart_type_name(chart_type)));
+ st->chart_type = rrdset_type_id(config_get(st->id, "chart type", rrdset_type_name(chart_type)));
- if(name && *name) rrd_stats_set_name(st, name);
- else rrd_stats_set_name(st, id);
+ if(name && *name) rrdset_set_name(st, name);
+ else rrdset_set_name(st, id);
{
char varvalue[CONFIG_MAX_VALUE + 1];
st->last_collected_time.tv_usec = 0;
st->counter_done = 0;
- st->gap_when_lost_iterations = config_get_number(st->id, "gap when lost iterations above", DEFAULT_GAP_INTERPOLATIONS);
+ st->gap_when_lost_iterations_above = config_get_number(st->id, "gap when lost iterations above", RRD_DEFAULT_GAP_INTERPOLATIONS);
+
+ st->dimensions_index.root = NULL;
+ st->dimensions_index.compar = rrddim_compare;
pthread_rwlock_init(&st->rwlock, NULL);
- pthread_rwlock_wrlock(&root_rwlock);
+ pthread_rwlock_wrlock(&rrdset_root_rwlock);
+
+ st->next = rrdset_root;
+ rrdset_root = st;
- st->next = root;
- root = st;
+ rrdset_index_add(st);
- pthread_rwlock_unlock(&root_rwlock);
+ pthread_rwlock_unlock(&rrdset_root_rwlock);
return(st);
}
-RRD_DIMENSION *rrd_stats_dimension_add(RRD_STATS *st, const char *id, const char *name, long multiplier, long divisor, int algorithm)
+RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, long multiplier, long divisor, int algorithm)
{
char filename[FILENAME_MAX + 1];
char fullfilename[FILENAME_MAX + 1];
char varname[CONFIG_MAX_NAME + 1];
- RRD_DIMENSION *rd = NULL;
- unsigned long size = sizeof(RRD_DIMENSION) + (st->entries * sizeof(storage_number));
+ RRDDIM *rd = NULL;
+ unsigned long size = sizeof(RRDDIM) + (st->entries * sizeof(storage_number));
debug(D_RRD_CALLS, "Adding dimension '%s/%s'.", st->id, id);
- rrd_stats_strncpy_name(filename, id, FILENAME_MAX);
+ rrdset_strncpy_name(filename, id, FILENAME_MAX);
snprintf(fullfilename, FILENAME_MAX, "%s/%s.db", st->cache_dir, filename);
- if(memory_mode != NETDATA_MEMORY_MODE_RAM) rd = (RRD_DIMENSION *)mymmap(fullfilename, size, ((memory_mode == NETDATA_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE));
+ if(rrd_memory_mode != RRD_MEMORY_MODE_RAM) rd = (RRDDIM *)mymmap(fullfilename, size, ((rrd_memory_mode == RRD_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE));
if(rd) {
struct timeval now;
gettimeofday(&now, NULL);
- if(strcmp(rd->magic, RRD_DIMENSION_MAGIC) != 0) {
+ if(strcmp(rd->magic, RRDDIMENSION_MAGIC) != 0) {
errno = 0;
info("Initializing file %s.", fullfilename);
bzero(rd, size);
if(rd) {
// we have a file mapped for rd
- rd->mapped = memory_mode;
+ rd->mapped = rrd_memory_mode;
rd->hidden = 0;
rd->next = NULL;
rd->name = NULL;
return NULL;
}
- rd->mapped = NETDATA_MEMORY_MODE_RAM;
+ rd->mapped = RRD_MEMORY_MODE_RAM;
}
rd->memsize = size;
- strcpy(rd->magic, RRD_DIMENSION_MAGIC);
- strcpy(rd->cache_file, fullfilename);
- strncpy(rd->id, id, RRD_STATS_NAME_MAX);
+ strcpy(rd->magic, RRDDIMENSION_MAGIC);
+ strcpy(rd->cache_filename, fullfilename);
+ strncpy(rd->id, id, RRD_ID_LENGTH_MAX);
rd->hash = simple_hash(rd->id);
snprintf(varname, CONFIG_MAX_NAME, "dim %s name", rd->id);
rd->name = config_get(st->id, varname, (name && *name)?name:rd->id);
snprintf(varname, CONFIG_MAX_NAME, "dim %s algorithm", rd->id);
- rd->algorithm = algorithm_id(config_get(st->id, varname, algorithm_name(algorithm)));
+ rd->algorithm = rrddim_algorithm_id(config_get(st->id, varname, rrddim_algorithm_name(algorithm)));
snprintf(varname, CONFIG_MAX_NAME, "dim %s multiplier", rd->id);
rd->multiplier = config_get_number(st->id, varname, multiplier);
if(!st->dimensions)
st->dimensions = rd;
else {
- RRD_DIMENSION *td = st->dimensions;
+ RRDDIM *td = st->dimensions;
for(; td->next; td = td->next) ;
td->next = rd;
}
+ rrddim_index_add(st, rd);
+
return(rd);
}
-void rrd_stats_dimension_set_name(RRD_STATS *st, RRD_DIMENSION *rd, const char *name)
+void rrddim_set_name(RRDSET *st, RRDDIM *rd, const char *name)
{
char varname[CONFIG_MAX_NAME + 1];
snprintf(varname, CONFIG_MAX_NAME, "dim %s name", rd->id);
config_get(st->id, varname, name);
}
-void rrd_stats_dimension_free(RRD_DIMENSION *rd)
+void rrddim_free(RRDSET *st, RRDDIM *rd)
{
- if(rd->next) rrd_stats_dimension_free(rd->next);
+ RRDDIM *i = st->dimensions, *last = NULL;
+ for(i = st->dimensions; i && i != rd ; i = i->next) last = i;
+
+ if(!i) {
+ error("Request to free dimension %s.%s but it is not linked.", st->id, rd->name);
+ return;
+ }
+
+ if(last) last = i->next;
+ else st->dimensions = i->next;
+
+ rrddim_index_del(st, rd);
+
// free(rd->annotations);
- if(rd->mapped == NETDATA_MEMORY_MODE_SAVE) {
- debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_file);
- savememory(rd->cache_file, rd, rd->memsize);
+ if(rd->mapped == RRD_MEMORY_MODE_SAVE) {
+ debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_filename);
+ savememory(rd->cache_filename, rd, rd->memsize);
debug(D_RRD_CALLS, "Unmapping dimension '%s'.", rd->name);
munmap(rd, rd->memsize);
}
- else if(rd->mapped == NETDATA_MEMORY_MODE_MAP) {
+ else if(rd->mapped == RRD_MEMORY_MODE_MAP) {
debug(D_RRD_CALLS, "Unmapping dimension '%s'.", rd->name);
munmap(rd, rd->memsize);
}
}
}
-void rrd_stats_free_all(void)
+void rrdset_free_all(void)
{
info("Freeing all memory...");
- RRD_STATS *st;
- for(st = root; st ;) {
- RRD_STATS *next = st->next;
+ RRDSET *st;
+ for(st = rrdset_root; st ;) {
+ RRDSET *next = st->next;
- if(st->dimensions) rrd_stats_dimension_free(st->dimensions);
- st->dimensions = NULL;
+ while(st->dimensions)
+ rrddim_free(st, st->dimensions);
- if(st->mapped == NETDATA_MEMORY_MODE_SAVE) {
- debug(D_RRD_CALLS, "Saving stats '%s' to '%s'.", st->name, st->cache_file);
- savememory(st->cache_file, st, st->memsize);
+ rrdset_index_del(st);
+
+ if(st->mapped == RRD_MEMORY_MODE_SAVE) {
+ debug(D_RRD_CALLS, "Saving stats '%s' to '%s'.", st->name, st->cache_filename);
+ savememory(st->cache_filename, st, st->memsize);
debug(D_RRD_CALLS, "Unmapping stats '%s'.", st->name);
munmap(st, st->memsize);
}
- else if(st->mapped == NETDATA_MEMORY_MODE_MAP) {
+ else if(st->mapped == RRD_MEMORY_MODE_MAP) {
debug(D_RRD_CALLS, "Unmapping stats '%s'.", st->name);
munmap(st, st->memsize);
}
st = next;
}
- root = NULL;
+ rrdset_root = NULL;
info("Memory cleanup completed...");
}
-void rrd_stats_save_all(void)
+void rrdset_save_all(void)
{
- RRD_STATS *st;
- RRD_DIMENSION *rd;
+ RRDSET *st;
+ RRDDIM *rd;
- pthread_rwlock_wrlock(&root_rwlock);
- for(st = root; st ; st = st->next) {
+ pthread_rwlock_wrlock(&rrdset_root_rwlock);
+ for(st = rrdset_root; st ; st = st->next) {
pthread_rwlock_wrlock(&st->rwlock);
- if(st->mapped == NETDATA_MEMORY_MODE_SAVE) {
- debug(D_RRD_CALLS, "Saving stats '%s' to '%s'.", st->name, st->cache_file);
- savememory(st->cache_file, st, st->memsize);
+ if(st->mapped == RRD_MEMORY_MODE_SAVE) {
+ debug(D_RRD_CALLS, "Saving stats '%s' to '%s'.", st->name, st->cache_filename);
+ savememory(st->cache_filename, st, st->memsize);
}
for(rd = st->dimensions; rd ; rd = rd->next) {
- if(rd->mapped == NETDATA_MEMORY_MODE_SAVE) {
- debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_file);
- savememory(rd->cache_file, rd, rd->memsize);
+ if(rd->mapped == RRD_MEMORY_MODE_SAVE) {
+ debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_filename);
+ savememory(rd->cache_filename, rd, rd->memsize);
}
}
pthread_rwlock_unlock(&st->rwlock);
}
- pthread_rwlock_unlock(&root_rwlock);
+ pthread_rwlock_unlock(&rrdset_root_rwlock);
}
-RRD_STATS *rrd_stats_find(const char *id)
+RRDSET *rrdset_find(const char *id)
{
debug(D_RRD_CALLS, "rrd_stats_find() for chart %s", id);
- unsigned long hash = simple_hash(id);
-
- pthread_rwlock_rdlock(&root_rwlock);
- RRD_STATS *st = root;
- for ( ; st ; st = st->next )
- if(hash == st->hash)
- if(strcmp(st->id, id) == 0)
- break;
- pthread_rwlock_unlock(&root_rwlock);
+ pthread_rwlock_rdlock(&rrdset_root_rwlock);
+ RRDSET *st = rrdset_index_find(id, 0);
+ pthread_rwlock_unlock(&rrdset_root_rwlock);
return(st);
}
-RRD_STATS *rrd_stats_find_bytype(const char *type, const char *id)
+RRDSET *rrdset_find_bytype(const char *type, const char *id)
{
debug(D_RRD_CALLS, "rrd_stats_find_bytype() for chart %s.%s", type, id);
- char buf[RRD_STATS_NAME_MAX + 1];
+ char buf[RRD_ID_LENGTH_MAX + 1];
- strncpy(buf, type, RRD_STATS_NAME_MAX - 1);
- buf[RRD_STATS_NAME_MAX - 1] = '\0';
+ strncpy(buf, type, RRD_ID_LENGTH_MAX - 1);
+ buf[RRD_ID_LENGTH_MAX - 1] = '\0';
strcat(buf, ".");
int len = strlen(buf);
- strncpy(&buf[len], id, RRD_STATS_NAME_MAX - len);
- buf[RRD_STATS_NAME_MAX] = '\0';
+ strncpy(&buf[len], id, RRD_ID_LENGTH_MAX - len);
+ buf[RRD_ID_LENGTH_MAX] = '\0';
- return(rrd_stats_find(buf));
+ return(rrdset_find(buf));
}
-RRD_STATS *rrd_stats_find_byname(const char *name)
+RRDSET *rrdset_find_byname(const char *name)
{
debug(D_RRD_CALLS, "rrd_stats_find_byname() for chart %s", name);
char b[CONFIG_MAX_VALUE + 1];
- rrd_stats_strncpy_name(b, name, CONFIG_MAX_VALUE);
+ rrdset_strncpy_name(b, name, CONFIG_MAX_VALUE);
unsigned long hash = simple_hash(b);
- pthread_rwlock_rdlock(&root_rwlock);
- RRD_STATS *st = root;
+ pthread_rwlock_rdlock(&rrdset_root_rwlock);
+ RRDSET *st = rrdset_root;
for ( ; st ; st = st->next ) {
if(hash == st->hash_name && strcmp(st->name, b) == 0) break;
}
- pthread_rwlock_unlock(&root_rwlock);
+ pthread_rwlock_unlock(&rrdset_root_rwlock);
return(st);
}
-RRD_DIMENSION *rrd_stats_dimension_find(RRD_STATS *st, const char *id)
+RRDDIM *rrddim_find(RRDSET *st, const char *id)
{
debug(D_RRD_CALLS, "rrd_stats_dimension_find() for chart %s, dimension %s", st->name, id);
- unsigned long hash = simple_hash(id);
-
- RRD_DIMENSION *rd = st->dimensions;
-
- for ( ; rd ; rd = rd->next )
- if(hash == rd->hash)
- if(strcmp(rd->id, id) == 0)
- break;
-
- return(rd);
+ return rrddim_index_find(st, id, 0);
}
-int rrd_stats_dimension_hide(RRD_STATS *st, const char *id)
+int rrddim_hide(RRDSET *st, const char *id)
{
debug(D_RRD_CALLS, "rrd_stats_dimension_hide() for chart %s, dimension %s", st->name, id);
- RRD_DIMENSION *rd = rrd_stats_dimension_find(st, id);
+ RRDDIM *rd = rrddim_find(st, id);
if(!rd) {
error("Cannot find dimension with id '%s' on stats '%s' (%s).", id, st->name, st->id);
return 1;
return 0;
}
-void rrd_stats_dimension_set_by_pointer(RRD_STATS *st, RRD_DIMENSION *rd, collected_number value)
+void rrddim_set_by_pointer(RRDSET *st, RRDDIM *rd, collected_number value)
{
debug(D_RRD_CALLS, "rrd_stats_dimension_set() for chart %s, dimension %s, value " COLLECTED_NUMBER_FORMAT, st->name, rd->name, value);
rd->updated = 1;
}
-int rrd_stats_dimension_set(RRD_STATS *st, const char *id, collected_number value)
+int rrddim_set(RRDSET *st, const char *id, collected_number value)
{
- RRD_DIMENSION *rd = rrd_stats_dimension_find(st, id);
+ RRDDIM *rd = rrddim_find(st, id);
if(!rd) {
error("Cannot find dimension with id '%s' on stats '%s' (%s).", id, st->name, st->id);
return 1;
}
- rrd_stats_dimension_set_by_pointer(st, rd, value);
+ rrddim_set_by_pointer(st, rd, value);
return 0;
}
-void rrd_stats_next_usec(RRD_STATS *st, unsigned long long microseconds)
+void rrdset_next_usec(RRDSET *st, unsigned long long microseconds)
{
debug(D_RRD_CALLS, "rrd_stats_next() for chart %s with microseconds %llu", st->name, microseconds);
st->usec_since_last_update = microseconds;
}
-void rrd_stats_next(RRD_STATS *st)
+void rrdset_next(RRDSET *st)
{
unsigned long long microseconds = 0;
microseconds = usecdiff(&now, &st->last_collected_time);
}
- rrd_stats_next_usec(st, microseconds);
+ rrdset_next_usec(st, microseconds);
}
-void rrd_stats_next_plugins(RRD_STATS *st)
+void rrdset_next_plugins(RRDSET *st)
{
- rrd_stats_next(st);
+ rrdset_next(st);
}
-unsigned long long rrd_stats_done(RRD_STATS *st)
+unsigned long long rrdset_done(RRDSET *st)
{
debug(D_RRD_CALLS, "rrd_stats_done() for chart %s", st->name);
- RRD_DIMENSION *rd, *last;
+ RRDDIM *rd, *last;
int oldstate, store_this_entry = 1;
if(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate) != 0)
// check if the chart has a long time to be refreshed
if(st->usec_since_last_update > st->entries * st->update_every * 1000000ULL) {
info("%s: took too long to be updated (%0.3Lf secs). Reseting it.", st->name, (long double)(st->usec_since_last_update / 1000000.0));
- rrd_stats_reset(st);
+ rrdset_reset(st);
st->usec_since_last_update = st->update_every * 1000000ULL;
}
if(st->debug) debug(D_RRD_STATS, "%s: microseconds since last update: %llu", st->name, st->usec_since_last_update);
// check if we will re-write the entire data set
if(usecdiff(&st->last_collected_time, &st->last_updated) > st->update_every * st->entries * 1000000ULL) {
info("%s: too old data (last updated at %u.%u, last collected at %u.%u). Reseting it. Will not store the next entry.", st->name, st->last_updated.tv_sec, st->last_updated.tv_usec, st->last_collected_time.tv_sec, st->last_collected_time.tv_usec);
- rrd_stats_reset(st);
+ rrdset_reset(st);
st->usec_since_last_update = st->update_every * 1000000ULL;
);
switch(rd->algorithm) {
- case RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_PCENT_OVER_DIFF_TOTAL:
// the percentage of the current increment
// over the increment of all dimensions together
if(st->collected_total == st->last_collected_total) rd->calculated_value = rd->last_calculated_value;
);
break;
- case RRD_DIMENSION_PCENT_OVER_ROW_TOTAL:
+ case RRDDIM_PCENT_OVER_ROW_TOTAL:
if(!st->collected_total) rd->calculated_value = 0;
else
// the percentage of the current value
);
break;
- case RRD_DIMENSION_INCREMENTAL:
+ case RRDDIM_INCREMENTAL:
// if the new is smaller than the old (an overflow, or reset), set the old equal to the new
// to reset the calculation (it will give zero as the calculation for this second)
if(rd->last_collected_value > rd->collected_value) {
+ info("%s.%s: Detect RESET or OVERFLOW. Last collected value = " COLLECTED_NUMBER_FORMAT ", current = " COLLECTED_NUMBER_FORMAT
+ , st->name, rd->name
+ , rd->last_collected_value
+ , rd->collected_value);
storage_flags = SN_EXISTS_RESET;
rd->last_collected_value = rd->collected_value;
}
);
break;
- case RRD_DIMENSION_ABSOLUTE:
+ case RRDDIM_ABSOLUTE:
rd->calculated_value = (calculated_number)rd->collected_value;
if(st->debug)
calculated_number new_value;
switch(rd->algorithm) {
- case RRD_DIMENSION_INCREMENTAL:
+ case RRDDIM_INCREMENTAL:
new_value = (calculated_number)
( rd->calculated_value
* (calculated_number)(next_ut - last_ut)
rd->calculated_value -= new_value;
break;
- case RRD_DIMENSION_ABSOLUTE:
- case RRD_DIMENSION_PCENT_OVER_ROW_TOTAL:
- case RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_ABSOLUTE:
+ case RRDDIM_PCENT_OVER_ROW_TOTAL:
+ case RRDDIM_PCENT_OVER_DIFF_TOTAL:
default:
new_value = (calculated_number)
( ( (rd->calculated_value - rd->last_calculated_value)
continue;
}
- if(rd->updated && iterations < st->gap_when_lost_iterations) {
+ if(rd->updated && iterations < st->gap_when_lost_iterations_above) {
rd->values[st->current_entry] = pack_storage_number(
new_value
* (calculated_number)rd->multiplier
// we have to set the first calculated_value to zero
// to eliminate the first spike
if(st->counter_done == 1) switch(rd->algorithm) {
- case RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL:
- case RRD_DIMENSION_INCREMENTAL:
+ case RRDDIM_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_INCREMENTAL:
rd->calculated_value = 0;
// the next time, a new incremental total will be calculated
break;
if(!last) {
st->dimensions = rd->next;
rd->next = NULL;
- rrd_stats_dimension_free(rd);
+ rrddim_free(st, rd);
rd = st->dimensions;
continue;
}
else {
last->next = rd->next;
rd->next = NULL;
- rrd_stats_dimension_free(rd);
+ rrddim_free(st, rd);
rd = last->next;
continue;
}
// find the oldest entry in the data, skipping all empty slots
-time_t rrd_stats_first_entry_t(RRD_STATS *st)
+time_t rrdset_first_entry_t(RRDSET *st)
{
if(!st->first_entry_t) return st->last_updated.tv_sec;
#include <sys/time.h>
#include <pthread.h>
+#include "avl.h"
#include "storage_number.h"
#ifndef NETDATA_RRD_H
#define UPDATE_EVERY 1
#define UPDATE_EVERY_MAX 3600
-extern int update_every;
+extern int rrd_update_every;
-#define HISTORY 3600
-#define HISTORY_MAX (86400*10)
-extern int save_history;
+#define RRD_DEFAULT_HISTORY_ENTRIES 3600
+#define RRD_HISTORY_ENTRIES_MAX (86400*10)
+extern int rrd_default_history_entries;
-#define DEFAULT_GAP_INTERPOLATIONS 10
+#define RRD_DEFAULT_GAP_INTERPOLATIONS 10
typedef long long total_number;
-
#define TOTAL_NUMBER_FORMAT "%lld"
-#define RRD_STATS_NAME_MAX 1024
-
-#define RRD_STATS_MAGIC "NETDATA CACHE STATS FILE V010"
-#define RRD_DIMENSION_MAGIC "NETDATA CACHE DIMENSION FILE V010"
+#define RRD_ID_LENGTH_MAX 1024
+#define RRDSET_MAGIC "NETDATA CACHE STATS FILE V011"
+#define RRDDIMENSION_MAGIC "NETDATA CACHE DIMENSION FILE V011"
// ----------------------------------------------------------------------------
// chart types
-#define CHART_TYPE_LINE_NAME "line"
-#define CHART_TYPE_AREA_NAME "area"
-#define CHART_TYPE_STACKED_NAME "stacked"
+#define RRDSET_TYPE_LINE_NAME "line"
+#define RRDSET_TYPE_AREA_NAME "area"
+#define RRDSET_TYPE_STACKED_NAME "stacked"
-#define CHART_TYPE_LINE 0
-#define CHART_TYPE_AREA 1
-#define CHART_TYPE_STACKED 2
+#define RRDSET_TYPE_LINE 0
+#define RRDSET_TYPE_AREA 1
+#define RRDSET_TYPE_STACKED 2
-int chart_type_id(const char *name);
-const char *chart_type_name(int chart_type);
+int rrdset_type_id(const char *name);
+const char *rrdset_type_name(int chart_type);
// ----------------------------------------------------------------------------
// memory mode
-#define NETDATA_MEMORY_MODE_RAM_NAME "ram"
-#define NETDATA_MEMORY_MODE_MAP_NAME "map"
-#define NETDATA_MEMORY_MODE_SAVE_NAME "save"
+#define RRD_MEMORY_MODE_RAM_NAME "ram"
+#define RRD_MEMORY_MODE_MAP_NAME "map"
+#define RRD_MEMORY_MODE_SAVE_NAME "save"
-#define NETDATA_MEMORY_MODE_RAM 0
-#define NETDATA_MEMORY_MODE_MAP 1
-#define NETDATA_MEMORY_MODE_SAVE 2
+#define RRD_MEMORY_MODE_RAM 0
+#define RRD_MEMORY_MODE_MAP 1
+#define RRD_MEMORY_MODE_SAVE 2
-extern int memory_mode;
+extern int rrd_memory_mode;
-extern const char *memory_mode_name(int id);
-extern int memory_mode_id(const char *name);
+extern const char *rrd_memory_mode_name(int id);
+extern int rrd_memory_mode_id(const char *name);
// ----------------------------------------------------------------------------
// algorithms types
-#define RRD_DIMENSION_ABSOLUTE_NAME "absolute"
-#define RRD_DIMENSION_INCREMENTAL_NAME "incremental"
-#define RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL_NAME "percentage-of-incremental-row"
-#define RRD_DIMENSION_PCENT_OVER_ROW_TOTAL_NAME "percentage-of-absolute-row"
+#define RRDDIM_ABSOLUTE_NAME "absolute"
+#define RRDDIM_INCREMENTAL_NAME "incremental"
+#define RRDDIM_PCENT_OVER_DIFF_TOTAL_NAME "percentage-of-incremental-row"
+#define RRDDIM_PCENT_OVER_ROW_TOTAL_NAME "percentage-of-absolute-row"
+
+#define RRDDIM_ABSOLUTE 0
+#define RRDDIM_INCREMENTAL 1
+#define RRDDIM_PCENT_OVER_DIFF_TOTAL 2
+#define RRDDIM_PCENT_OVER_ROW_TOTAL 3
+
+extern int rrddim_algorithm_id(const char *name);
+extern const char *rrddim_algorithm_name(int chart_type);
-#define RRD_DIMENSION_ABSOLUTE 0
-#define RRD_DIMENSION_INCREMENTAL 1
-#define RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL 2
-#define RRD_DIMENSION_PCENT_OVER_ROW_TOTAL 3
-extern int algorithm_id(const char *name);
-extern const char *algorithm_name(int chart_type);
+// ----------------------------------------------------------------------------
+// RRD DIMENSION
+
+struct rrddim {
+ avl avl;
-struct rrd_dimension {
- char magic[sizeof(RRD_DIMENSION_MAGIC) + 1]; // our magic
- char id[RRD_STATS_NAME_MAX + 1]; // the id of this dimension (for internal identification)
- char *name; // the name of this dimension (as presented to user)
- char cache_file[FILENAME_MAX+1];
+ char magic[sizeof(RRDDIMENSION_MAGIC) + 1]; // our magic
+ char id[RRD_ID_LENGTH_MAX + 1]; // the id of this dimension (for internal identification)
+ const char *name; // the name of this dimension (as presented to user)
+ char cache_filename[FILENAME_MAX+1];
unsigned long hash; // a simple hash on the id, to speed up searching
// we first compare hashes, and only if the hashes are equal we do string comparisons
calculated_number collected_volume;
calculated_number stored_volume;
- struct rrd_dimension *next; // linking of dimensions within the same data set
+ struct rrddim *next; // linking of dimensions within the same data set
storage_number values[]; // the array of values - THIS HAS TO BE THE LAST MEMBER
};
-typedef struct rrd_dimension RRD_DIMENSION;
+typedef struct rrddim RRDDIM;
+
+
+// ----------------------------------------------------------------------------
+// RRDSET
+
+struct rrdset {
+ avl avl;
-struct rrd_stats {
- char magic[sizeof(RRD_STATS_MAGIC) + 1]; // our magic
+ char magic[sizeof(RRDSET_MAGIC) + 1]; // our magic
- char id[RRD_STATS_NAME_MAX + 1]; // id of the data set
- char *name; // name of the data set
+ char id[RRD_ID_LENGTH_MAX + 1]; // id of the data set
+ const char *name; // name of the data set
char *cache_dir; // the directory to store dimension maps
- char cache_file[FILENAME_MAX+1];
+ char cache_filename[FILENAME_MAX+1];
char *type; // the type of graph RRD_TYPE_* (a category, for determining graphing options)
char *family; // the family of this data set (for grouping them together)
unsigned long hash; // a simple hash on the id, to speed up searching
// we first compare hashes, and only if the hashes are equal we do string comparisons
- int gap_when_lost_iterations; // after how many lost iterations a gap should be stored
+ int gap_when_lost_iterations_above; // after how many lost iterations a gap should be stored
// netdata will interpolate values for gaps lower than this
long priority;
int isdetail; // if set, the data set should be considered as a detail of another
// (the master data set should be the one that has the same family and is not detail)
- RRD_DIMENSION *dimensions; // the actual data for every dimension
+ RRDDIM *dimensions; // the actual data for every dimension
- struct rrd_stats *next; // linking of rrd stats
+ avl_tree dimensions_index;
+
+ struct rrdset *next; // linking of rrdsets
};
-typedef struct rrd_stats RRD_STATS;
+typedef struct rrdset RRDSET;
+
+extern RRDSET *rrdset_root;
+extern pthread_rwlock_t rrdset_root_rwlock;
-extern RRD_STATS *root;
-extern pthread_rwlock_t root_rwlock;
+// ----------------------------------------------------------------------------
+// RRD SET functions
+
+extern char *rrdset_strncpy_name(char *to, const char *from, int length);
+extern void rrdset_set_name(RRDSET *st, const char *name);
-extern char *rrd_stats_strncpy_name(char *to, const char *from, int length);
-extern void rrd_stats_set_name(RRD_STATS *st, const char *name);
+extern char *rrdset_cache_dir(const char *id);
-extern char *rrd_stats_cache_dir(const char *id);
+extern void rrdset_reset(RRDSET *st);
-extern void rrd_stats_reset(RRD_STATS *st);
+extern RRDSET *rrdset_create(const char *type, const char *id, const char *name, const char *family, const char *title, const char *units, long priority, int update_every, int chart_type);
-extern RRD_STATS *rrd_stats_create(const char *type, const char *id, const char *name, const char *family, const char *title, const char *units, long priority, int update_every, int chart_type);
+extern void rrdset_free_all(void);
+extern void rrdset_save_all(void);
-extern RRD_DIMENSION *rrd_stats_dimension_add(RRD_STATS *st, const char *id, const char *name, long multiplier, long divisor, int algorithm);
+extern RRDSET *rrdset_find(const char *id);
+extern RRDSET *rrdset_find_bytype(const char *type, const char *id);
+extern RRDSET *rrdset_find_byname(const char *name);
-extern void rrd_stats_dimension_set_name(RRD_STATS *st, RRD_DIMENSION *rd, const char *name);
-extern void rrd_stats_dimension_free(RRD_DIMENSION *rd);
+extern void rrdset_next_usec(RRDSET *st, unsigned long long microseconds);
+extern void rrdset_next(RRDSET *st);
+extern void rrdset_next_plugins(RRDSET *st);
-extern void rrd_stats_free_all(void);
-extern void rrd_stats_save_all(void);
+extern unsigned long long rrdset_done(RRDSET *st);
-extern RRD_STATS *rrd_stats_find(const char *id);
-extern RRD_STATS *rrd_stats_find_bytype(const char *type, const char *id);
-extern RRD_STATS *rrd_stats_find_byname(const char *name);
+extern time_t rrdset_first_entry_t(RRDSET *st);
-extern RRD_DIMENSION *rrd_stats_dimension_find(RRD_STATS *st, const char *id);
-extern int rrd_stats_dimension_hide(RRD_STATS *st, const char *id);
+// ----------------------------------------------------------------------------
+// RRD DIMENSION functions
+
+extern RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, long multiplier, long divisor, int algorithm);
-extern void rrd_stats_dimension_set_by_pointer(RRD_STATS *st, RRD_DIMENSION *rd, collected_number value);
-extern int rrd_stats_dimension_set(RRD_STATS *st, const char *id, collected_number value);
+extern void rrddim_set_name(RRDSET *st, RRDDIM *rd, const char *name);
+extern void rrddim_free(RRDSET *st, RRDDIM *rd);
-extern void rrd_stats_next_usec(RRD_STATS *st, unsigned long long microseconds);
-extern void rrd_stats_next(RRD_STATS *st);
-extern void rrd_stats_next_plugins(RRD_STATS *st);
+extern RRDDIM *rrddim_find(RRDSET *st, const char *id);
-extern unsigned long long rrd_stats_done(RRD_STATS *st);
+extern int rrddim_hide(RRDSET *st, const char *id);
-extern time_t rrd_stats_first_entry_t(RRD_STATS *st);
+extern void rrddim_set_by_pointer(RRDSET *st, RRDDIM *rd, collected_number value);
+extern int rrddim_set(RRDSET *st, const char *id, collected_number value);
#endif /* NETDATA_RRD_H */
#define HOSTNAME_MAX 1024
char *hostname = "unknown";
-unsigned long rrd_stats_one_json(RRD_STATS *st, char *options, struct web_buffer *wb)
+unsigned long rrd_stats_one_json(RRDSET *st, char *options, struct web_buffer *wb)
{
time_t now = time(NULL);
web_buffer_increase(wb, 16384);
, st->enabled
, st->units
, st->name, options?options:""
- , chart_type_name(st->chart_type)
+ , rrdset_type_name(st->chart_type)
, st->counter
, st->entries
- , rrd_stats_first_entry_t(st)
+ , rrdset_first_entry_t(st)
, st->current_entry
, st->last_updated.tv_sec
, now - (st->last_updated.tv_sec > now) ? now : st->last_updated.tv_sec
unsigned long memory = st->memsize;
- RRD_DIMENSION *rd;
+ RRDDIM *rd;
for(rd = st->dimensions; rd ; rd = rd->next) {
memory += rd->memsize;
, rd->name
, rd->entries
, rd->hidden
- , algorithm_name(rd->algorithm)
+ , rrddim_algorithm_name(rd->algorithm)
, rd->multiplier
, rd->divisor
, rd->last_collected_time.tv_sec
#define RRD_GRAPH_JSON_HEADER "{\n\t\"charts\": [\n"
#define RRD_GRAPH_JSON_FOOTER "\n\t]\n}\n"
-void rrd_stats_graph_json(RRD_STATS *st, char *options, struct web_buffer *wb)
+void rrd_stats_graph_json(RRDSET *st, char *options, struct web_buffer *wb)
{
web_buffer_increase(wb, 16384);
unsigned long memory = 0;
long c;
- RRD_STATS *st;
+ RRDSET *st;
web_buffer_printf(wb, RRD_GRAPH_JSON_HEADER);
- pthread_rwlock_rdlock(&root_rwlock);
- for(st = root, c = 0; st ; st = st->next) {
+ pthread_rwlock_rdlock(&rrdset_root_rwlock);
+ for(st = rrdset_root, c = 0; st ; st = st->next) {
if(st->enabled) {
if(c) web_buffer_printf(wb, "%s", ",\n");
memory += rrd_stats_one_json(st, NULL, wb);
c++;
}
}
- pthread_rwlock_unlock(&root_rwlock);
+ pthread_rwlock_unlock(&rrdset_root_rwlock);
web_buffer_printf(wb, "\n\t],\n"
"\t\"hostname\": \"%s\",\n"
"\t\"memory\": %lu\n"
"}\n"
, hostname
- , update_every
- , save_history
+ , rrd_update_every
+ , rrd_default_history_entries
, memory
);
}
-unsigned long rrd_stats_json(int type, RRD_STATS *st, struct web_buffer *wb, int entries_to_show, int group, int group_method, time_t after, time_t before, int only_non_zero)
+unsigned long rrd_stats_json(int type, RRDSET *st, struct web_buffer *wb, int entries_to_show, int group, int group_method, time_t after, time_t before, int only_non_zero)
{
int c;
pthread_rwlock_rdlock(&st->rwlock);
time_t time_init = st->last_updated.tv_sec;
if(before == 0 || before > time_init) before = time_init;
- if(after == 0) after = rrd_stats_first_entry_t(st);
+ if(after == 0) after = rrdset_first_entry_t(st);
// ---
// find how many dimensions we have
int dimensions = 0;
- RRD_DIMENSION *rd;
+ RRDDIM *rd;
for( rd = st->dimensions ; rd ; rd = rd->next) dimensions++;
if(!dimensions) {
pthread_rwlock_unlock(&st->rwlock);
if(st->debug) {
debug(D_RRD_STATS, "%s first_entry_t = %lu, last_entry_t = %lu, duration = %lu, after = %lu, before = %lu, duration = %lu, entries_to_show = %lu, group = %lu, max_entries = %ld"
, st->id
- , rrd_stats_first_entry_t(st)
+ , rrdset_first_entry_t(st)
, st->last_updated.tv_sec
- , st->last_updated.tv_sec - rrd_stats_first_entry_t(st)
+ , st->last_updated.tv_sec - rrdset_first_entry_t(st)
, after
, before
, before - after
#define GROUP_MAX 1
#define GROUP_SUM 2
-extern unsigned long rrd_stats_one_json(RRD_STATS *st, char *options, struct web_buffer *wb);
+extern unsigned long rrd_stats_one_json(RRDSET *st, char *options, struct web_buffer *wb);
-extern void rrd_stats_graph_json(RRD_STATS *st, char *options, struct web_buffer *wb);
+extern void rrd_stats_graph_json(RRDSET *st, char *options, struct web_buffer *wb);
extern void rrd_stats_all_json(struct web_buffer *wb);
-extern unsigned long rrd_stats_json(int type, RRD_STATS *st, struct web_buffer *wb, int entries_to_show, int group, int group_method, time_t after, time_t before, int only_non_zero);
+extern unsigned long rrd_stats_json(int type, RRDSET *st, struct web_buffer *wb, int entries_to_show, int group, int group_method, time_t after, time_t before, int only_non_zero);
#endif /* NETDATA_RRD2JSON_H */
snprintf(name, 100, "unittest-%d-%ld-%ld", repeat, delay, shift);
debug_flags = 0xffffffff;
- memory_mode = NETDATA_MEMORY_MODE_RAM;
- update_every = 1;
+ rrd_memory_mode = RRD_MEMORY_MODE_RAM;
+ rrd_update_every = 1;
int do_abs = 1;
int do_inc = 1;
int do_abst = 1;
int do_absi = 1;
- RRD_STATS *st = rrd_stats_create("netdata", name, name, "netdata", "Unit Testing", "a value", 1, 1, CHART_TYPE_LINE);
+ RRDSET *st = rrdset_create("netdata", name, name, "netdata", "Unit Testing", "a value", 1, 1, RRDSET_TYPE_LINE);
st->debug = 1;
- RRD_DIMENSION *rdabs = NULL;
- RRD_DIMENSION *rdinc = NULL;
- RRD_DIMENSION *rdabst = NULL;
- RRD_DIMENSION *rdabsi = NULL;
+ RRDDIM *rdabs = NULL;
+ RRDDIM *rdinc = NULL;
+ RRDDIM *rdabst = NULL;
+ RRDDIM *rdabsi = NULL;
- if(do_abs) rdabs = rrd_stats_dimension_add(st, "absolute", "absolute", 1, 1, RRD_DIMENSION_ABSOLUTE);
- if(do_inc) rdinc = rrd_stats_dimension_add(st, "incremental", "incremental", 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
- if(do_abst) rdabst = rrd_stats_dimension_add(st, "percentage-of-absolute-row", "percentage-of-absolute-row", 1, 1, RRD_DIMENSION_PCENT_OVER_ROW_TOTAL);
- if(do_absi) rdabsi = rrd_stats_dimension_add(st, "percentage-of-incremental-row", "percentage-of-incremental-row", 1, 1, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
+ if(do_abs) rdabs = rrddim_add(st, "absolute", "absolute", 1, 1, RRDDIM_ABSOLUTE);
+ if(do_inc) rdinc = rrddim_add(st, "incremental", "incremental", 1, 1 * rrd_update_every, RRDDIM_INCREMENTAL);
+ if(do_abst) rdabst = rrddim_add(st, "percentage-of-absolute-row", "percentage-of-absolute-row", 1, 1, RRDDIM_PCENT_OVER_ROW_TOTAL);
+ if(do_absi) rdabsi = rrddim_add(st, "percentage-of-incremental-row", "percentage-of-incremental-row", 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
long increment = 1000;
collected_number i = 0;
unsigned long c, dimensions = 0;
- RRD_DIMENSION *rd;
+ RRDDIM *rd;
for(rd = st->dimensions ; rd ; rd = rd->next) dimensions++;
for(c = 0; c < 20 ;c++) {
fprintf(stderr, "\n\nLOOP = %lu, DELAY = %ld, VALUE = " COLLECTED_NUMBER_FORMAT "\n", c, delay, i);
if(c) {
- rrd_stats_next_usec(st, delay);
+ rrdset_next_usec(st, delay);
}
- if(do_abs) rrd_stats_dimension_set(st, "absolute", i);
- if(do_inc) rrd_stats_dimension_set(st, "incremental", i);
- if(do_abst) rrd_stats_dimension_set(st, "percentage-of-absolute-row", i);
- if(do_absi) rrd_stats_dimension_set(st, "percentage-of-incremental-row", i);
+ if(do_abs) rrddim_set(st, "absolute", i);
+ if(do_inc) rrddim_set(st, "incremental", i);
+ if(do_abst) rrddim_set(st, "percentage-of-absolute-row", i);
+ if(do_absi) rrddim_set(st, "percentage-of-incremental-row", i);
if(!c) {
gettimeofday(&st->last_collected_time, NULL);
// prevent it from deleting the dimensions
for(rd = st->dimensions ; rd ; rd = rd->next) rd->last_collected_time.tv_sec = st->last_collected_time.tv_sec;
- rrd_stats_done(st);
+ rrdset_done(st);
}
unsigned long oincrement = increment;
#include <sys/stat.h>
#include <fcntl.h>
#include <netinet/tcp.h>
+#include <malloc.h>
#include "common.h"
#include "log.h"
int listen_fd = -1;
int listen_port = LISTEN_PORT;
+static void log_allocations(void)
+{
+ static int mem = 0;
+
+ struct mallinfo mi;
+
+ mi = mallinfo();
+ if(mi.uordblks > mem) {
+ int clients = 0;
+ struct web_client *w;
+ for(w = web_clients; w ; w = w->next) clients++;
+
+ info("Allocated memory increased from %d to %d (increased by %d bytes). There are %d web clients connected.", mem, mi.uordblks, mi.uordblks - mem, clients);
+ mem = mi.uordblks;
+ }
+}
+
int create_listen_socket(int port)
{
int sock=-1;
debug(D_WEB_CLIENT, "%llu: Searching for RRD data with name '%s'.", w->id, tok);
// do we have such a data set?
- RRD_STATS *st = rrd_stats_find_byname(tok);
- if(!st) st = rrd_stats_find(tok);
+ RRDSET *st = rrdset_find_byname(tok);
+ if(!st) st = rrdset_find(tok);
if(!st) {
// we don't have it
// try to send a file with that name
debug(D_WEB_CLIENT, "%llu: Found RRD data with name '%s'.", w->id, tok);
// how many entries does the client want?
- long lines = save_history;
+ long lines = rrd_default_history_entries;
long group_count = 1;
time_t after = 0, before = 0;
int group_method = GROUP_AVERAGE;
debug(D_WEB_CLIENT, "%llu: Searching for RRD data with name '%s'.", w->id, tok);
// do we have such a data set?
- RRD_STATS *st = rrd_stats_find_byname(tok);
+ RRDSET *st = rrdset_find_byname(tok);
if(!st) {
// we don't have it
// try to send a file with that name
debug(D_WEB_CLIENT, "%llu: Searching for RRD data with name '%s'.", w->id, tok);
// do we have such a data set?
- RRD_STATS *st = rrd_stats_find_byname(tok);
+ RRDSET *st = rrdset_find_byname(tok);
if(!st) {
code = 404;
web_buffer_printf(w->data, "Chart %s is not found.\r\n", tok);
debug(D_WEB_CLIENT_ACCESS, "%llu: Sending list of RRD_STATS...", w->id);
w->data->bytes = 0;
- RRD_STATS *st = root;
+ RRDSET *st = rrdset_root;
for ( ; st ; st = st->next )
web_buffer_printf(w->data, "%s\n", st->name);
projects / netdata.git / commitdiff