1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
|
#include <sys/time.h>
#include <pthread.h>
#include <stdint.h>
#include "avl.h"
#include "storage_number.h"
#ifndef NETDATA_RRD_H
#define NETDATA_RRD_H 1
#define UPDATE_EVERY 1
#define UPDATE_EVERY_MAX 3600
extern int rrd_update_every;
#define RRD_DEFAULT_HISTORY_ENTRIES 3600
#define RRD_HISTORY_ENTRIES_MAX (86400*10)
extern int rrd_default_history_entries;
// time in seconds to delete unupdated dimensions
// set to zero to disable this feature
extern int rrd_delete_unupdated_dimensions;
#define RRD_ID_LENGTH_MAX 1024
#define RRDSET_MAGIC "NETDATA RRD SET FILE V017"
#define RRDDIMENSION_MAGIC "NETDATA RRD DIMENSION FILE V017"
typedef long long total_number;
#define TOTAL_NUMBER_FORMAT "%lld"
// ----------------------------------------------------------------------------
// chart types
#define RRDSET_TYPE_LINE_NAME "line"
#define RRDSET_TYPE_AREA_NAME "area"
#define RRDSET_TYPE_STACKED_NAME "stacked"
#define RRDSET_TYPE_LINE 0
#define RRDSET_TYPE_AREA 1
#define RRDSET_TYPE_STACKED 2
int rrdset_type_id(const char *name);
const char *rrdset_type_name(int chart_type);
// ----------------------------------------------------------------------------
// memory mode
#define RRD_MEMORY_MODE_RAM_NAME "ram"
#define RRD_MEMORY_MODE_MAP_NAME "map"
#define RRD_MEMORY_MODE_SAVE_NAME "save"
#define RRD_MEMORY_MODE_RAM 0
#define RRD_MEMORY_MODE_MAP 1
#define RRD_MEMORY_MODE_SAVE 2
extern int rrd_memory_mode;
extern const char *rrd_memory_mode_name(int id);
extern int rrd_memory_mode_id(const char *name);
// ----------------------------------------------------------------------------
// algorithms types
#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);
// ----------------------------------------------------------------------------
// flags
#define RRDDIM_FLAG_HIDDEN 0x00000001 // this dimension will not be offered to callers
#define RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS 0x00000002 // do not offer RESET or OVERFLOW info to callers
// ----------------------------------------------------------------------------
// RRD DIMENSION
struct rrddim {
// ------------------------------------------------------------------------
// binary indexing structures
avl avl; // the binary index - this has to be first member!
// ------------------------------------------------------------------------
// the dimension definition
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)
// this is a pointer to the config structure
// since the config always has a higher priority
// (the user overwrites the name of the charts)
int algorithm; // the algorithm that is applied to add new collected values
long multiplier; // the multiplier of the collected values
long divisor; // the divider of the collected values
int mapped; // if set to non zero, this dimension is mapped to a file
// ------------------------------------------------------------------------
// members for temporary data we need for calculations
uint32_t hash; // a simple hash of the id, to speed up searching / indexing
// instead of strcmp() every item in the binary index
// we first compare the hashes
uint32_t flags;
char cache_filename[FILENAME_MAX+1]; // the filename we load/save from/to this set
unsigned long counter; // the number of times we added values to this rrdim
int updated; // set to 0 after each calculation, to 1 after each collected value
// we use this to detect that a dimension is not updated
struct timeval last_collected_time; // when was this dimension last updated
// this is actual date time we updated the last_collected_value
// THIS IS DIFFERENT FROM THE SAME MEMBER OF RRDSET
calculated_number calculated_value; // the current calculated value, after applying the algorithm
calculated_number last_calculated_value; // the last calculated value
collected_number collected_value; // the current value, as collected
collected_number last_collected_value; // the last value that was collected
// the *_volume members are used to calculate the accuracy of the rounding done by the
// storage number - they are printed to debug.log when debug is enabled for a set.
calculated_number collected_volume; // the sum of all collected values so far
calculated_number stored_volume; // the sum of all stored values so far
struct rrddim *next; // linking of dimensions within the same data set
// ------------------------------------------------------------------------
// members for checking the data when loading from disk
long entries; // how many entries this dimension has in ram
// this is the same to the entries of the data set
// we set it here, to check the data when we load it from disk.
int update_every; // every how many seconds is this updated
unsigned long memsize; // the memory allocated for this dimension
char magic[sizeof(RRDDIMENSION_MAGIC) + 1]; // a string to be saved, used to identify our data file
// ------------------------------------------------------------------------
// the values stored in this dimension, using our floating point numbers
storage_number values[]; // the array of values - THIS HAS TO BE THE LAST MEMBER
};
typedef struct rrddim RRDDIM;
// ----------------------------------------------------------------------------
// RRDSET
struct rrdset {
// ------------------------------------------------------------------------
// binary indexing structures
avl avl; // the index, with key the id - this has to be first!
avl avlname; // the index, with key the name
// ------------------------------------------------------------------------
// the set configuration
char id[RRD_ID_LENGTH_MAX + 1]; // id of the data set
const char *name; // the name of this dimension (as presented to user)
// this is a pointer to the config structure
// since the config always has a higher priority
// (the user overwrites the name of the charts)
char *type; // the type of graph RRD_TYPE_* (a category, for determining graphing options)
char *family; // grouping sets under the same family
char *context; // the template of this data set
char *title; // title shown to user
char *units; // units of measurement
int chart_type;
int update_every; // every how many seconds is this updated?
long entries; // total number of entries in the data set
long current_entry; // the entry that is currently being updated
// it goes around in a round-robin fashion
int enabled;
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)
// ------------------------------------------------------------------------
// members for temporary data we need for calculations
int mapped; // if set to 1, this is memory mapped
int debug;
char *cache_dir; // the directory to store dimensions
char cache_filename[FILENAME_MAX+1]; // the filename to store this set
pthread_rwlock_t rwlock;
unsigned long counter; // the number of times we added values to this rrd
unsigned long counter_done; // the number of times we added values to this rrd
uint32_t 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
uint32_t hash_name; // a simple hash on the name
unsigned long long usec_since_last_update; // the time in microseconds since the last collection of data
struct timeval last_updated; // when this data set was last updated (updated every time the rrd_stats_done() function)
struct timeval last_collected_time; // when did this data set last collected values
total_number collected_total; // used internally to calculate percentages
total_number last_collected_total; // used internally to calculate percentages
struct rrdset *next; // linking of rrdsets
// ------------------------------------------------------------------------
// members for checking the data when loading from disk
unsigned long memsize; // how much mem we have allocated for this (without dimensions)
char magic[sizeof(RRDSET_MAGIC) + 1]; // our magic
// ------------------------------------------------------------------------
// the dimensions
avl_tree dimensions_index; // the root of the dimensions index
RRDDIM *dimensions; // the actual data for every dimension
};
typedef struct rrdset RRDSET;
extern RRDSET *rrdset_root;
extern pthread_rwlock_t rrdset_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 *rrdset_cache_dir(const char *id);
extern void rrdset_reset(RRDSET *st);
extern RRDSET *rrdset_create(const char *type
, const char *id
, const char *name
, const char *family
, const char *context
, 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 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 rrdset_next_usec(RRDSET *st, unsigned long long microseconds);
extern void rrdset_next(RRDSET *st);
extern void rrdset_next_plugins(RRDSET *st);
extern unsigned long long rrdset_done(RRDSET *st);
// get the total duration in seconds of the round robin database
#define rrdset_duration(st) ((time_t)( (((st)->counter >= ((unsigned long)(st)->entries))?(unsigned long)(st)->entries:(st)->counter) * (st)->update_every ))
// get the timestamp of the last entry in the round robin database
#define rrdset_last_entry_t(st) ((time_t)(((st)->last_updated.tv_sec)))
// get the timestamp of first entry in the round robin database
#define rrdset_first_entry_t(st) ((time_t)(rrdset_last_entry_t(st) - rrdset_duration(st)))
// get the last slot updated in the round robin database
#define rrdset_last_slot(st) ((unsigned long)(((st)->current_entry == 0) ? (st)->entries - 1 : (st)->current_entry - 1))
// get the first / oldest slot updated in the round robin database
#define rrdset_first_slot(st) ((unsigned long)( (((st)->counter >= ((unsigned long)(st)->entries)) ? (unsigned long)( ((unsigned long)(st)->current_entry > 0) ? ((unsigned long)(st)->current_entry) : ((unsigned long)(st)->entries) ) - 1 : 0) ))
// get the slot of the round robin database, for the given timestamp (t)
// it always returns a valid slot, although may not be for the time requested if the time is outside the round robin database
#define rrdset_time2slot(st, t) ( \
( (time_t)(t) >= rrdset_last_entry_t(st)) ? ( rrdset_last_slot(st) ) : \
( ((time_t)(t) <= rrdset_first_entry_t(st)) ? rrdset_first_slot(st) : \
( (rrdset_last_slot(st) >= (unsigned long)((rrdset_last_entry_t(st) - (time_t)(t)) / (unsigned long)((st)->update_every)) ) ? \
(rrdset_last_slot(st) - (unsigned long)((rrdset_last_entry_t(st) - (time_t)(t)) / (unsigned long)((st)->update_every)) ) : \
(rrdset_last_slot(st) - (unsigned long)((rrdset_last_entry_t(st) - (time_t)(t)) / (unsigned long)((st)->update_every)) + (unsigned long)(st)->entries ) \
)))
// get the timestamp of a specific slot in the round robin database
#define rrdset_slot2time(st, slot) ( rrdset_last_entry_t(st) - \
((unsigned long)(st)->update_every * ( \
( (unsigned long)(slot) > rrdset_last_slot(st)) ? \
( (rrdset_last_slot(st) - (unsigned long)(slot) + (unsigned long)(st)->entries) ) : \
( (rrdset_last_slot(st) - (unsigned long)(slot)) )) \
))
// ----------------------------------------------------------------------------
// RRD DIMENSION functions
extern RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, long multiplier, long divisor, int algorithm);
extern void rrddim_set_name(RRDSET *st, RRDDIM *rd, const char *name);
extern void rrddim_free(RRDSET *st, RRDDIM *rd);
extern RRDDIM *rrddim_find(RRDSET *st, const char *id);
extern int rrddim_hide(RRDSET *st, const char *id);
extern int rrddim_unhide(RRDSET *st, const char *id);
extern collected_number rrddim_set_by_pointer(RRDSET *st, RRDDIM *rd, collected_number value);
extern collected_number rrddim_set(RRDSET *st, const char *id, collected_number value);
#endif /* NETDATA_RRD_H */
|