src/health.h

   1 #ifndef NETDATA_HEALTH_H
   2 #define NETDATA_HEALTH_H
   3
   4 extern int health_enabled;
   5
   6 extern int rrdvar_compare(void *a, void *b);
   7
   8 #define RRDVAR_TYPE_CALCULATED 1
   9 #define RRDVAR_TYPE_TIME_T     2
  10 #define RRDVAR_TYPE_COLLECTED  3
  11 #define RRDVAR_TYPE_TOTAL      4
  12 #define RRDVAR_TYPE_INT        5
  13
  14 // the variables as stored in the variables indexes
  15 // there are 3 indexes:
  16 // 1. at each chart   (RRDSET.variables_root_index)
  17 // 2. at each context (RRDFAMILY.variables_root_index)
  18 // 3. at each host    (RRDHOST.variables_root_index)
  19 typedef struct rrdvar {
  20     avl avl;
  21
  22     char *name;
  23     uint32_t hash;
  24
  25     int type;
  26     void *value;
  27
  28     time_t last_updated;
  29 } RRDVAR;
  30
  31 // variables linked to charts
  32 // We link variables to point to the values that are already
  33 // calculated / processed by the normal data collection process
  34 // This means, there will be no speed penalty for using
  35 // these variables
  36 typedef struct rrdsetvar {
  37     char *fullid;               // chart type.chart id.variable
  38     char *fullname;             // chart type.chart name.variable
  39     char *variable;             // variable
  40
  41     int type;
  42     void *value;
  43
  44     uint32_t options;
  45
  46     RRDVAR *local;
  47     RRDVAR *family;
  48     RRDVAR *host;
  49     RRDVAR *family_name;
  50     RRDVAR *host_name;
  51
  52     struct rrdset *rrdset;
  53
  54     struct rrdsetvar *next;
  55 } RRDSETVAR;
  56
  57
  58 // variables linked to individual dimensions
  59 // We link variables to point the values that are already
  60 // calculated / processed by the normal data collection process
  61 // This means, there will be no speed penalty for using
  62 // these variables
  63 typedef struct rrddimvar {
  64     char *prefix;
  65     char *suffix;
  66
  67     char *id;                   // dimension id
  68     char *name;                 // dimension name
  69     char *contextid;            // context + dimension id
  70     char *contextname;          // context + dimension name
  71     char *fullidid;             // chart type.chart id + dimension id
  72     char *fullidname;           // chart type.chart id + dimension name
  73     char *fullnameid;           // chart type.chart name + dimension id
  74     char *fullnamename;         // chart type.chart name + dimension name
  75
  76     int type;
  77     void *value;
  78
  79     uint32_t options;
  80
  81     RRDVAR *local_id;
  82     RRDVAR *local_name;
  83
  84     RRDVAR *family_id;
  85     RRDVAR *family_name;
  86     RRDVAR *family_contextid;
  87     RRDVAR *family_contextname;
  88
  89     RRDVAR *host_fullidid;
  90     RRDVAR *host_fullidname;
  91     RRDVAR *host_fullnameid;
  92     RRDVAR *host_fullnamename;
  93
  94     struct rrddim *rrddim;
  95
  96     struct rrddimvar *next;
  97 } RRDDIMVAR;
  98
  99 // calculated variables (defined in health configuration)
 100 // These aggregate time-series data at fixed intervals
 101 // (defined in their update_every member below)
 102 // These increase the overhead of netdata.
 103 //
 104 // These calculations are allocated and linked (->next)
 105 // under RRDHOST.
 106 // Then are also linked to RRDSET (of course only when the
 107 // chart is found, via ->rrdset_next and ->rrdset_prev).
 108 // This double-linked list is maintained sorted at all times
 109 // having as RRDSET.calculations the RRDCALC to be processed
 110 // next.
 111
 112 #define RRDCALC_STATUS_REMOVED       -2
 113 #define RRDCALC_STATUS_UNDEFINED     -1
 114 #define RRDCALC_STATUS_UNINITIALIZED  0
 115 #define RRDCALC_STATUS_CLEAR          1
 116 #define RRDCALC_STATUS_RAISED         2
 117 #define RRDCALC_STATUS_WARNING        3
 118 #define RRDCALC_STATUS_CRITICAL       4
 119
 120 #define RRDCALC_FLAG_DB_ERROR      0x00000001
 121 #define RRDCALC_FLAG_DB_NAN        0x00000002
 122 /* #define RRDCALC_FLAG_DB_STALE      0x00000004 */
 123 #define RRDCALC_FLAG_CALC_ERROR    0x00000008
 124 #define RRDCALC_FLAG_WARN_ERROR    0x00000010
 125 #define RRDCALC_FLAG_CRIT_ERROR    0x00000020
 126 #define RRDCALC_FLAG_RUNNABLE      0x00000040
 127
 128 typedef struct rrdcalc {
 129     uint32_t id;                    // the unique id of this alarm
 130     uint32_t next_event_id;         // the next event id that will be used for this alarm
 131
 132     char *name;                     // the name of this alarm
 133     uint32_t hash;
 134
 135     char *exec;                     // the command to execute when this alarm switches state
 136     char *recipient;                // the recipient of the alarm (the first parameter to exec)
 137
 138     char *chart;                    // the chart id this should be linked to
 139     uint32_t hash_chart;
 140
 141     char *source;                   // the source of this alarm
 142     char *units;                    // the units of the alarm
 143     char *info;                     // a short description of the alarm
 144
 145     int update_every;               // update frequency for the alarm
 146
 147     // the red and green threshold of this alarm (to be set to the chart)
 148     calculated_number green;
 149     calculated_number red;
 150
 151     // ------------------------------------------------------------------------
 152     // database lookup settings
 153
 154     char *dimensions;               // the chart dimensions
 155     int group;                      // grouping method: average, max, etc.
 156     int before;                     // ending point in time-series
 157     int after;                      // starting point in time-series
 158     uint32_t options;               // calculation options
 159
 160     // ------------------------------------------------------------------------
 161     // expressions related to the alarm
 162
 163     EVAL_EXPRESSION *calculation;   // expression to calculate the value of the alarm
 164     EVAL_EXPRESSION *warning;       // expression to check the warning condition
 165     EVAL_EXPRESSION *critical;      // expression to check the critical condition
 166
 167     // ------------------------------------------------------------------------
 168     // notification delay settings
 169
 170     int delay_up_duration;         // duration to delay notifications when alarm raises
 171     int delay_down_duration;       // duration to delay notifications when alarm lowers
 172     int delay_max_duration;        // the absolute max delay to apply to this alarm
 173     float delay_multiplier;        // multiplier for all delays when alarms switch status
 174                                    // while now < delay_up_to
 175
 176     // ------------------------------------------------------------------------
 177     // runtime information
 178
 179     int status;                     // the current status of the alarm
 180
 181     calculated_number value;        // the current value of the alarm
 182     calculated_number old_value;    // the previous value of the alarm
 183
 184     uint32_t rrdcalc_flags;         // check RRDCALC_FLAG_*
 185
 186     time_t last_updated;            // the last update timestamp of the alarm
 187     time_t next_update;             // the next update timestamp of the alarm
 188     time_t last_status_change;      // the timestamp of the last time this alarm changed status
 189
 190     time_t db_after;                // the first timestamp evaluated by the db lookup
 191     time_t db_before;               // the last timestamp evaluated by the db lookup
 192
 193     time_t delay_up_to_timestamp;   // the timestamp up to which we should delay notifications
 194     int delay_up_current;           // the current up notification delay duration
 195     int delay_down_current;         // the current down notification delay duration
 196     int delay_last;                 // the last delay we used
 197
 198     // ------------------------------------------------------------------------
 199     // variables this alarm exposes to the rest of the alarms
 200
 201     RRDVAR *local;
 202     RRDVAR *family;
 203     RRDVAR *hostid;
 204     RRDVAR *hostname;
 205
 206     // ------------------------------------------------------------------------
 207     // the chart this alarm it is linked to
 208
 209     struct rrdset *rrdset;
 210
 211     // linking of this alarm on its chart
 212     struct rrdcalc *rrdset_next;
 213     struct rrdcalc *rrdset_prev;
 214
 215     struct rrdcalc *next;
 216 } RRDCALC;
 217
 218 #define RRDCALC_HAS_DB_LOOKUP(rc) ((rc)->after)
 219
 220 // RRDCALCTEMPLATE
 221 // these are to be applied to charts found dynamically
 222 // based on their context.
 223 typedef struct rrdcalctemplate {
 224     char *name;
 225     uint32_t hash_name;
 226
 227     char *exec;
 228     char *recipient;
 229
 230     char *context;
 231     uint32_t hash_context;
 232
 233     char *source;                   // the source of this alarm
 234     char *units;                    // the units of the alarm
 235     char *info;                     // a short description of the alarm
 236
 237     int update_every;               // update frequency for the alarm
 238
 239     // the red and green threshold of this alarm (to be set to the chart)
 240     calculated_number green;
 241     calculated_number red;
 242
 243     // ------------------------------------------------------------------------
 244     // database lookup settings
 245
 246     char *dimensions;               // the chart dimensions
 247     int group;                      // grouping method: average, max, etc.
 248     int before;                     // ending point in time-series
 249     int after;                      // starting point in time-series
 250     uint32_t options;               // calculation options
 251
 252     // ------------------------------------------------------------------------
 253     // notification delay settings
 254
 255     int delay_up_duration;         // duration to delay notifications when alarm raises
 256     int delay_down_duration;       // duration to delay notifications when alarm lowers
 257     int delay_max_duration;        // the absolute max delay to apply to this alarm
 258     float delay_multiplier;        // multiplier for all delays when alarms switch status
 259
 260     // ------------------------------------------------------------------------
 261     // expressions related to the alarm
 262
 263     EVAL_EXPRESSION *calculation;
 264     EVAL_EXPRESSION *warning;
 265     EVAL_EXPRESSION *critical;
 266
 267     struct rrdcalctemplate *next;
 268 } RRDCALCTEMPLATE;
 269
 270 #define RRDCALCTEMPLATE_HAS_CALCULATION(rt) ((rt)->after)
 271
 272 #define HEALTH_ENTRY_FLAG_PROCESSED    0x00000001
 273 #define HEALTH_ENTRY_FLAG_UPDATED      0x00000002
 274 #define HEALTH_ENTRY_FLAG_EXEC_RUN     0x00000004
 275 #define HEALTH_ENTRY_FLAG_EXEC_FAILED  0x00000008
 276 #define HEALTH_ENTRY_FLAG_SAVED        0x10000000
 277
 278 typedef struct alarm_entry {
 279     uint32_t unique_id;
 280     uint32_t alarm_id;
 281     uint32_t alarm_event_id;
 282
 283     time_t when;
 284     time_t duration;
 285     time_t non_clear_duration;
 286
 287     char *name;
 288     uint32_t hash_name;
 289
 290     char *chart;
 291     uint32_t hash_chart;
 292
 293     char *family;
 294
 295     char *exec;
 296     char *recipient;
 297     time_t exec_run_timestamp;
 298     int exec_code;
 299
 300     char *source;
 301     char *units;
 302     char *info;
 303
 304     calculated_number old_value;
 305     calculated_number new_value;
 306     int old_status;
 307     int new_status;
 308
 309     uint32_t flags;
 310
 311     int delay;
 312     time_t delay_up_to_timestamp;
 313
 314     uint32_t updated_by_id;
 315     uint32_t updates_id;
 316
 317     struct alarm_entry *next;
 318 } ALARM_ENTRY;
 319
 320 typedef struct alarm_log {
 321     uint32_t next_log_id;
 322     uint32_t next_alarm_id;
 323     unsigned int count;
 324     unsigned int max;
 325     ALARM_ENTRY *alarms;
 326     pthread_rwlock_t alarm_log_rwlock;
 327 } ALARM_LOG;
 328
 329 #include "rrd.h"
 330
 331 extern void rrdsetvar_rename_all(RRDSET *st);
 332 extern RRDSETVAR *rrdsetvar_create(RRDSET *st, const char *variable, int type, void *value, uint32_t options);
 333 extern void rrdsetvar_free(RRDSETVAR *rs);
 334
 335 extern void rrddimvar_rename_all(RRDDIM *rd);
 336 extern RRDDIMVAR *rrddimvar_create(RRDDIM *rd, int type, const char *prefix, const char *suffix, void *value, uint32_t options);
 337 extern void rrddimvar_free(RRDDIMVAR *rs);
 338
 339 extern void rrdsetcalc_link_matching(RRDSET *st);
 340 extern void rrdsetcalc_unlink(RRDCALC *rc);
 341 extern void rrdcalctemplate_link_matching(RRDSET *st);
 342 extern RRDCALC *rrdcalc_find(RRDSET *st, const char *name);
 343
 344 extern void health_init(void);
 345 extern void *health_main(void *ptr);
 346
 347 extern void health_reload(void);
 348
 349 extern int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, calculated_number *result);
 350 extern void health_alarms2json(RRDHOST *host, BUFFER *wb, int all);
 351 extern void health_alarm_log2json(RRDHOST *host, BUFFER *wb, uint32_t after);
 352
 353 #endif //NETDATA_HEALTH_H