src/database/contexts/api_v2.c
// SPDX-License-Identifier: GPL-3.0-or-later
#include "internal.h"
#include "aclk/aclk_capas.h"
// ----------------------------------------------------------------------------
// /api/v2/contexts API
struct alert_transitions_facets alert_transition_facets[] = {
[ATF_STATUS] = {
.id = "f_status",
.name = "Alert Status",
.query_param = "f_status",
.order = 1,
},
[ATF_TYPE] = {
.id = "f_type",
.name = "Alert Type",
.query_param = "f_type",
.order = 2,
},
[ATF_ROLE] = {
.id = "f_role",
.name = "Recipient Role",
.query_param = "f_role",
.order = 3,
},
[ATF_CLASS] = {
.id = "f_class",
.name = "Alert Class",
.query_param = "f_class",
.order = 4,
},
[ATF_COMPONENT] = {
.id = "f_component",
.name = "Alert Component",
.query_param = "f_component",
.order = 5,
},
[ATF_NODE] = {
.id = "f_node",
.name = "Alert Node",
.query_param = "f_node",
.order = 6,
},
[ATF_ALERT_NAME] = {
.id = "f_alert",
.name = "Alert Name",
.query_param = "f_alert",
.order = 7,
},
[ATF_CHART_NAME] = {
.id = "f_instance",
.name = "Instance Name",
.query_param = "f_instance",
.order = 8,
},
[ATF_CONTEXT] = {
.id = "f_context",
.name = "Context",
.query_param = "f_context",
.order = 9,
},
// terminator
[ATF_TOTAL_ENTRIES] = {
.id = NULL,
.name = NULL,
.query_param = NULL,
.order = 9999,
}
};
struct facet_entry {
uint32_t count;
};
struct alert_transitions_callback_data {
struct rrdcontext_to_json_v2_data *ctl;
BUFFER *wb;
bool debug;
bool only_one_config;
struct {
SIMPLE_PATTERN *pattern;
DICTIONARY *dict;
} facets[ATF_TOTAL_ENTRIES];
uint32_t max_items_to_return;
uint32_t items_to_return;
uint32_t items_evaluated;
uint32_t items_matched;
struct sql_alert_transition_fixed_size *base; // double linked list - last item is base->prev
struct sql_alert_transition_fixed_size *last_added; // the last item added, not the last of the list
struct {
size_t first;
size_t skips_before;
size_t skips_after;
size_t backwards;
size_t forwards;
size_t prepend;
size_t append;
size_t shifts;
} operations;
uint32_t configs_added;
};
typedef enum __attribute__ ((__packed__)) {
FTS_MATCHED_NONE = 0,
FTS_MATCHED_HOST,
FTS_MATCHED_CONTEXT,
FTS_MATCHED_INSTANCE,
FTS_MATCHED_DIMENSION,
FTS_MATCHED_LABEL,
FTS_MATCHED_ALERT,
FTS_MATCHED_ALERT_INFO,
FTS_MATCHED_FAMILY,
FTS_MATCHED_TITLE,
FTS_MATCHED_UNITS,
} FTS_MATCH;
static const char *fts_match_to_string(FTS_MATCH match) {
switch(match) {
case FTS_MATCHED_HOST:
return "HOST";
case FTS_MATCHED_CONTEXT:
return "CONTEXT";
case FTS_MATCHED_INSTANCE:
return "INSTANCE";
case FTS_MATCHED_DIMENSION:
return "DIMENSION";
case FTS_MATCHED_ALERT:
return "ALERT";
case FTS_MATCHED_ALERT_INFO:
return "ALERT_INFO";
case FTS_MATCHED_LABEL:
return "LABEL";
case FTS_MATCHED_FAMILY:
return "FAMILY";
case FTS_MATCHED_TITLE:
return "TITLE";
case FTS_MATCHED_UNITS:
return "UNITS";
default:
return "NONE";
}
}
struct function_v2_entry {
size_t size;
size_t used;
size_t *node_ids;
STRING *help;
STRING *tags;
HTTP_ACCESS access;
int priority;
};
struct context_v2_entry {
size_t count;
STRING *id;
STRING *family;
uint32_t priority;
time_t first_time_s;
time_t last_time_s;
RRD_FLAGS flags;
FTS_MATCH match;
};
struct alert_counts {
size_t critical;
size_t warning;
size_t clear;
size_t error;
};
struct alert_v2_entry {
RRDCALC *tmp;
STRING *name;
STRING *summary;
size_t ati;
struct alert_counts counts;
size_t instances;
DICTIONARY *nodes;
DICTIONARY *configs;
};
struct alert_by_x_entry {
struct {
struct alert_counts counts;
size_t silent;
size_t total;
} running;
struct {
size_t available;
} prototypes;
};
typedef struct full_text_search_index {
size_t searches;
size_t string_searches;
size_t char_searches;
} FTS_INDEX;
static inline bool full_text_search_string(FTS_INDEX *fts, SIMPLE_PATTERN *q, STRING *ptr) {
fts->searches++;
fts->string_searches++;
return simple_pattern_matches_string(q, ptr);
}
static inline bool full_text_search_char(FTS_INDEX *fts, SIMPLE_PATTERN *q, char *ptr) {
fts->searches++;
fts->char_searches++;
return simple_pattern_matches(q, ptr);
}
struct contexts_v2_node {
size_t ni;
RRDHOST *host;
};
struct rrdcontext_to_json_v2_data {
time_t now;
BUFFER *wb;
struct api_v2_contexts_request *request;
CONTEXTS_V2_MODE mode;
CONTEXTS_V2_OPTIONS options;
struct query_versions versions;
struct {
SIMPLE_PATTERN *scope_pattern;
SIMPLE_PATTERN *pattern;
size_t ni;
DICTIONARY *dict; // the result set
} nodes;
struct {
SIMPLE_PATTERN *scope_pattern;
SIMPLE_PATTERN *pattern;
size_t ci;
DICTIONARY *dict; // the result set
} contexts;
struct {
SIMPLE_PATTERN *alert_name_pattern;
time_t alarm_id_filter;
size_t ati;
DICTIONARY *summary;
DICTIONARY *alert_instances;
DICTIONARY *by_type;
DICTIONARY *by_component;
DICTIONARY *by_classification;
DICTIONARY *by_recipient;
DICTIONARY *by_module;
} alerts;
struct {
FTS_MATCH host_match;
char host_node_id_str[UUID_STR_LEN];
SIMPLE_PATTERN *pattern;
FTS_INDEX fts;
} q;
struct {
DICTIONARY *dict; // the result set
} functions;
struct {
bool enabled;
bool relative;
time_t after;
time_t before;
} window;
struct query_timings timings;
};
static void alert_counts_add(struct alert_counts *t, RRDCALC *rc) {
switch(rc->status) {
case RRDCALC_STATUS_CRITICAL:
t->critical++;
break;
case RRDCALC_STATUS_WARNING:
t->warning++;
break;
case RRDCALC_STATUS_CLEAR:
t->clear++;
break;
case RRDCALC_STATUS_REMOVED:
case RRDCALC_STATUS_UNINITIALIZED:
break;
case RRDCALC_STATUS_UNDEFINED:
default:
if(!netdata_double_isnumber(rc->value))
t->error++;
break;
}
}
static void alerts_v2_add(struct alert_v2_entry *t, RRDCALC *rc) {
t->instances++;
alert_counts_add(&t->counts, rc);
dictionary_set(t->nodes, rc->rrdset->rrdhost->machine_guid, NULL, 0);
char key[UUID_STR_LEN + 1];
uuid_unparse_lower(rc->config.hash_id, key);
dictionary_set(t->configs, key, NULL, 0);
}
static void alerts_by_x_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data) {
static STRING *silent = NULL;
if(unlikely(!silent)) silent = string_strdupz("silent");
struct alert_by_x_entry *b = value;
RRDCALC *rc = data;
if(!rc) {
// prototype
b->prototypes.available++;
}
else {
alert_counts_add(&b->running.counts, rc);
b->running.total++;
if (rc->config.recipient == silent)
b->running.silent++;
}
}
static bool alerts_by_x_conflict_callback(const DICTIONARY_ITEM *item __maybe_unused, void *old_value, void *new_value __maybe_unused, void *data __maybe_unused) {
alerts_by_x_insert_callback(item, old_value, data);
return false;
}
static void alerts_v2_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data) {
struct rrdcontext_to_json_v2_data *ctl = data;
struct alert_v2_entry *t = value;
RRDCALC *rc = t->tmp;
t->name = rc->config.name;
t->summary = rc->config.summary; // the original summary
t->ati = ctl->alerts.ati++;
t->nodes = dictionary_create(DICT_OPTION_SINGLE_THREADED|DICT_OPTION_VALUE_LINK_DONT_CLONE|DICT_OPTION_NAME_LINK_DONT_CLONE);
t->configs = dictionary_create(DICT_OPTION_SINGLE_THREADED|DICT_OPTION_VALUE_LINK_DONT_CLONE|DICT_OPTION_NAME_LINK_DONT_CLONE);
alerts_v2_add(t, rc);
}
static bool alerts_v2_conflict_callback(const DICTIONARY_ITEM *item __maybe_unused, void *old_value, void *new_value, void *data __maybe_unused) {
struct alert_v2_entry *t = old_value, *n = new_value;
RRDCALC *rc = n->tmp;
alerts_v2_add(t, rc);
return true;
}
static void alerts_v2_delete_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused) {
struct alert_v2_entry *t = value;
dictionary_destroy(t->nodes);
dictionary_destroy(t->configs);
}
static void alert_instances_v2_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data) {
struct rrdcontext_to_json_v2_data *ctl = data;
struct sql_alert_instance_v2_entry *t = value;
RRDCALC *rc = t->tmp;
t->context = rc->rrdset->context;
t->chart_id = rc->rrdset->id;
t->chart_name = rc->rrdset->name;
t->family = rc->rrdset->family;
t->units = rc->config.units;
t->classification = rc->config.classification;
t->type = rc->config.type;
t->recipient = rc->config.recipient;
t->component = rc->config.component;
t->name = rc->config.name;
t->source = rc->config.source;
t->status = rc->status;
t->flags = rc->run_flags;
t->info = rc->config.info;
t->summary = rc->summary;
t->value = rc->value;
t->last_updated = rc->last_updated;
t->last_status_change = rc->last_status_change;
t->last_status_change_value = rc->last_status_change_value;
t->host = rc->rrdset->rrdhost;
t->alarm_id = rc->id;
t->ni = ctl->nodes.ni;
uuid_copy(t->config_hash_id, rc->config.hash_id);
health_alarm_log_get_global_id_and_transition_id_for_rrdcalc(rc, &t->global_id, &t->last_transition_id);
}
static bool alert_instances_v2_conflict_callback(const DICTIONARY_ITEM *item __maybe_unused, void *old_value __maybe_unused, void *new_value __maybe_unused, void *data __maybe_unused) {
internal_fatal(true, "This should never happen!");
return true;
}
static void alert_instances_delete_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value __maybe_unused, void *data __maybe_unused) {
;
}
static FTS_MATCH rrdcontext_to_json_v2_full_text_search(struct rrdcontext_to_json_v2_data *ctl, RRDCONTEXT *rc, SIMPLE_PATTERN *q) {
if(unlikely(full_text_search_string(&ctl->q.fts, q, rc->id) ||
full_text_search_string(&ctl->q.fts, q, rc->family)))
return FTS_MATCHED_CONTEXT;
if(unlikely(full_text_search_string(&ctl->q.fts, q, rc->title)))
return FTS_MATCHED_TITLE;
if(unlikely(full_text_search_string(&ctl->q.fts, q, rc->units)))
return FTS_MATCHED_UNITS;
FTS_MATCH matched = FTS_MATCHED_NONE;
RRDINSTANCE *ri;
dfe_start_read(rc->rrdinstances, ri) {
if(matched) break;
if(ctl->window.enabled && !query_matches_retention(ctl->window.after, ctl->window.before, ri->first_time_s, (ri->flags & RRD_FLAG_COLLECTED) ? ctl->now : ri->last_time_s, 0))
continue;
if(unlikely(full_text_search_string(&ctl->q.fts, q, ri->id)) ||
(ri->name != ri->id && full_text_search_string(&ctl->q.fts, q, ri->name))) {
matched = FTS_MATCHED_INSTANCE;
break;
}
RRDMETRIC *rm;
dfe_start_read(ri->rrdmetrics, rm) {
if(ctl->window.enabled && !query_matches_retention(ctl->window.after, ctl->window.before, rm->first_time_s, (rm->flags & RRD_FLAG_COLLECTED) ? ctl->now : rm->last_time_s, 0))
continue;
if(unlikely(full_text_search_string(&ctl->q.fts, q, rm->id)) ||
(rm->name != rm->id && full_text_search_string(&ctl->q.fts, q, rm->name))) {
matched = FTS_MATCHED_DIMENSION;
break;
}
}
dfe_done(rm);
size_t label_searches = 0;
if(unlikely(ri->rrdlabels && rrdlabels_entries(ri->rrdlabels) &&
rrdlabels_match_simple_pattern_parsed(ri->rrdlabels, q, ':', &label_searches) == SP_MATCHED_POSITIVE)) {
ctl->q.fts.searches += label_searches;
ctl->q.fts.char_searches += label_searches;
matched = FTS_MATCHED_LABEL;
break;
}
ctl->q.fts.searches += label_searches;
ctl->q.fts.char_searches += label_searches;
if(ri->rrdset) {
RRDSET *st = ri->rrdset;
rw_spinlock_read_lock(&st->alerts.spinlock);
for (RRDCALC *rcl = st->alerts.base; rcl; rcl = rcl->next) {
if(unlikely(full_text_search_string(&ctl->q.fts, q, rcl->config.name))) {
matched = FTS_MATCHED_ALERT;
break;
}
if(unlikely(full_text_search_string(&ctl->q.fts, q, rcl->config.info))) {
matched = FTS_MATCHED_ALERT_INFO;
break;
}
}
rw_spinlock_read_unlock(&st->alerts.spinlock);
}
}
dfe_done(ri);
return matched;
}
static bool rrdcontext_matches_alert(struct rrdcontext_to_json_v2_data *ctl, RRDCONTEXT *rc) {
size_t matches = 0;
RRDINSTANCE *ri;
dfe_start_read(rc->rrdinstances, ri) {
if(ri->rrdset) {
RRDSET *st = ri->rrdset;
rw_spinlock_read_lock(&st->alerts.spinlock);
for (RRDCALC *rcl = st->alerts.base; rcl; rcl = rcl->next) {
if(ctl->alerts.alert_name_pattern && !simple_pattern_matches_string(ctl->alerts.alert_name_pattern, rcl->config.name))
continue;
if(ctl->alerts.alarm_id_filter && ctl->alerts.alarm_id_filter != rcl->id)
continue;
size_t m = ctl->request->alerts.status & CONTEXTS_V2_ALERT_STATUSES ? 0 : 1;
if (!m) {
if ((ctl->request->alerts.status & CONTEXT_V2_ALERT_UNINITIALIZED) &&
rcl->status == RRDCALC_STATUS_UNINITIALIZED)
m++;
if ((ctl->request->alerts.status & CONTEXT_V2_ALERT_UNDEFINED) &&
rcl->status == RRDCALC_STATUS_UNDEFINED)
m++;
if ((ctl->request->alerts.status & CONTEXT_V2_ALERT_CLEAR) &&
rcl->status == RRDCALC_STATUS_CLEAR)
m++;
if ((ctl->request->alerts.status & CONTEXT_V2_ALERT_RAISED) &&
rcl->status >= RRDCALC_STATUS_RAISED)
m++;
if ((ctl->request->alerts.status & CONTEXT_V2_ALERT_WARNING) &&
rcl->status == RRDCALC_STATUS_WARNING)
m++;
if ((ctl->request->alerts.status & CONTEXT_V2_ALERT_CRITICAL) &&
rcl->status == RRDCALC_STATUS_CRITICAL)
m++;
if(!m)
continue;
}
struct alert_v2_entry t = {
.tmp = rcl,
};
struct alert_v2_entry *a2e =
dictionary_set(ctl->alerts.summary, string2str(rcl->config.name),
&t, sizeof(struct alert_v2_entry));
size_t ati = a2e->ati;
matches++;
dictionary_set_advanced(ctl->alerts.by_type,
string2str(rcl->config.type),
(ssize_t)string_strlen(rcl->config.type),
NULL,
sizeof(struct alert_by_x_entry),
rcl);
dictionary_set_advanced(ctl->alerts.by_component,
string2str(rcl->config.component),
(ssize_t)string_strlen(rcl->config.component),
NULL,
sizeof(struct alert_by_x_entry),
rcl);
dictionary_set_advanced(ctl->alerts.by_classification,
string2str(rcl->config.classification),
(ssize_t)string_strlen(rcl->config.classification),
NULL,
sizeof(struct alert_by_x_entry),
rcl);
dictionary_set_advanced(ctl->alerts.by_recipient,
string2str(rcl->config.recipient),
(ssize_t)string_strlen(rcl->config.recipient),
NULL,
sizeof(struct alert_by_x_entry),
rcl);
char *module = NULL;
rrdlabels_get_value_strdup_or_null(st->rrdlabels, &module, "_collect_module");
if(!module || !*module) module = "[unset]";
dictionary_set_advanced(ctl->alerts.by_module,
module,
-1,
NULL,
sizeof(struct alert_by_x_entry),
rcl);
if (ctl->options & (CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES | CONTEXT_V2_OPTION_ALERTS_WITH_VALUES)) {
char key[20 + 1];
snprintfz(key, sizeof(key) - 1, "%p", rcl);
struct sql_alert_instance_v2_entry z = {
.ati = ati,
.tmp = rcl,
};
dictionary_set(ctl->alerts.alert_instances, key, &z, sizeof(z));
}
}
rw_spinlock_read_unlock(&st->alerts.spinlock);
}
}
dfe_done(ri);
return matches != 0;
}
static ssize_t rrdcontext_to_json_v2_add_context(void *data, RRDCONTEXT_ACQUIRED *rca, bool queryable_context __maybe_unused) {
struct rrdcontext_to_json_v2_data *ctl = data;
RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
if(ctl->window.enabled && !query_matches_retention(ctl->window.after, ctl->window.before, rc->first_time_s, (rc->flags & RRD_FLAG_COLLECTED) ? ctl->now : rc->last_time_s, 0))
return 0; // continue to next context
FTS_MATCH match = ctl->q.host_match;
if((ctl->mode & CONTEXTS_V2_SEARCH) && ctl->q.pattern) {
match = rrdcontext_to_json_v2_full_text_search(ctl, rc, ctl->q.pattern);
if(match == FTS_MATCHED_NONE)
return 0; // continue to next context
}
if(ctl->mode & CONTEXTS_V2_ALERTS) {
if(!rrdcontext_matches_alert(ctl, rc))
return 0; // continue to next context
}
if(ctl->contexts.dict) {
struct context_v2_entry t = {
.count = 1,
.id = rc->id,
.family = string_dup(rc->family),
.priority = rc->priority,
.first_time_s = rc->first_time_s,
.last_time_s = rc->last_time_s,
.flags = rc->flags,
.match = match,
};
dictionary_set(ctl->contexts.dict, string2str(rc->id), &t, sizeof(struct context_v2_entry));
}
return 1;
}
void buffer_json_agent_status_id(BUFFER *wb, size_t ai, usec_t duration_ut) {
buffer_json_member_add_object(wb, "st");
{
buffer_json_member_add_uint64(wb, "ai", ai);
buffer_json_member_add_uint64(wb, "code", 200);
buffer_json_member_add_string(wb, "msg", "");
if (duration_ut)
buffer_json_member_add_double(wb, "ms", (NETDATA_DOUBLE) duration_ut / 1000.0);
}
buffer_json_object_close(wb);
}
void buffer_json_node_add_v2(BUFFER *wb, RRDHOST *host, size_t ni, usec_t duration_ut, bool status) {
buffer_json_member_add_string(wb, "mg", host->machine_guid);
if(host->node_id)
buffer_json_member_add_uuid(wb, "nd", host->node_id);
buffer_json_member_add_string(wb, "nm", rrdhost_hostname(host));
buffer_json_member_add_uint64(wb, "ni", ni);
if(status)
buffer_json_agent_status_id(wb, 0, duration_ut);
}
static void rrdhost_receiver_to_json(BUFFER *wb, RRDHOST_STATUS *s, const char *key) {
buffer_json_member_add_object(wb, key);
{
buffer_json_member_add_uint64(wb, "id", s->ingest.id);
buffer_json_member_add_uint64(wb, "hops", s->ingest.hops);
buffer_json_member_add_string(wb, "type", rrdhost_ingest_type_to_string(s->ingest.type));
buffer_json_member_add_string(wb, "status", rrdhost_ingest_status_to_string(s->ingest.status));
buffer_json_member_add_time_t(wb, "since", s->ingest.since);
buffer_json_member_add_time_t(wb, "age", s->now - s->ingest.since);
if(s->ingest.type == RRDHOST_INGEST_TYPE_CHILD) {
if(s->ingest.status == RRDHOST_INGEST_STATUS_OFFLINE)
buffer_json_member_add_string(wb, "reason", stream_handshake_error_to_string(s->ingest.reason));
if(s->ingest.status == RRDHOST_INGEST_STATUS_REPLICATING) {
buffer_json_member_add_object(wb, "replication");
{
buffer_json_member_add_boolean(wb, "in_progress", s->ingest.replication.in_progress);
buffer_json_member_add_double(wb, "completion", s->ingest.replication.completion);
buffer_json_member_add_uint64(wb, "instances", s->ingest.replication.instances);
}
buffer_json_object_close(wb); // replication
}
if(s->ingest.status == RRDHOST_INGEST_STATUS_REPLICATING || s->ingest.status == RRDHOST_INGEST_STATUS_ONLINE) {
buffer_json_member_add_object(wb, "source");
{
char buf[1024 + 1];
snprintfz(buf, sizeof(buf) - 1, "[%s]:%d%s", s->ingest.peers.local.ip, s->ingest.peers.local.port, s->ingest.ssl ? ":SSL" : "");
buffer_json_member_add_string(wb, "local", buf);
snprintfz(buf, sizeof(buf) - 1, "[%s]:%d%s", s->ingest.peers.peer.ip, s->ingest.peers.peer.port, s->ingest.ssl ? ":SSL" : "");
buffer_json_member_add_string(wb, "remote", buf);
stream_capabilities_to_json_array(wb, s->ingest.capabilities, "capabilities");
}
buffer_json_object_close(wb); // source
}
}
}
buffer_json_object_close(wb); // collection
}
static void rrdhost_sender_to_json(BUFFER *wb, RRDHOST_STATUS *s, const char *key) {
if(s->stream.status == RRDHOST_STREAM_STATUS_DISABLED)
return;
buffer_json_member_add_object(wb, key);
{
buffer_json_member_add_uint64(wb, "id", s->stream.id);
buffer_json_member_add_uint64(wb, "hops", s->stream.hops);
buffer_json_member_add_string(wb, "status", rrdhost_streaming_status_to_string(s->stream.status));
buffer_json_member_add_time_t(wb, "since", s->stream.since);
buffer_json_member_add_time_t(wb, "age", s->now - s->stream.since);
if (s->stream.status == RRDHOST_STREAM_STATUS_OFFLINE)
buffer_json_member_add_string(wb, "reason", stream_handshake_error_to_string(s->stream.reason));
if (s->stream.status == RRDHOST_STREAM_STATUS_REPLICATING) {
buffer_json_member_add_object(wb, "replication");
{
buffer_json_member_add_boolean(wb, "in_progress", s->stream.replication.in_progress);
buffer_json_member_add_double(wb, "completion", s->stream.replication.completion);
buffer_json_member_add_uint64(wb, "instances", s->stream.replication.instances);
}
buffer_json_object_close(wb);
}
buffer_json_member_add_object(wb, "destination");
{
char buf[1024 + 1];
snprintfz(buf, sizeof(buf) - 1, "[%s]:%d%s", s->stream.peers.local.ip, s->stream.peers.local.port, s->stream.ssl ? ":SSL" : "");
buffer_json_member_add_string(wb, "local", buf);
snprintfz(buf, sizeof(buf) - 1, "[%s]:%d%s", s->stream.peers.peer.ip, s->stream.peers.peer.port, s->stream.ssl ? ":SSL" : "");
buffer_json_member_add_string(wb, "remote", buf);
stream_capabilities_to_json_array(wb, s->stream.capabilities, "capabilities");
buffer_json_member_add_object(wb, "traffic");
{
buffer_json_member_add_boolean(wb, "compression", s->stream.compression);
buffer_json_member_add_uint64(wb, "data", s->stream.sent_bytes_on_this_connection_per_type[STREAM_TRAFFIC_TYPE_DATA]);
buffer_json_member_add_uint64(wb, "metadata", s->stream.sent_bytes_on_this_connection_per_type[STREAM_TRAFFIC_TYPE_METADATA]);
buffer_json_member_add_uint64(wb, "functions", s->stream.sent_bytes_on_this_connection_per_type[STREAM_TRAFFIC_TYPE_FUNCTIONS]);
buffer_json_member_add_uint64(wb, "replication", s->stream.sent_bytes_on_this_connection_per_type[STREAM_TRAFFIC_TYPE_REPLICATION]);
buffer_json_member_add_uint64(wb, "dyncfg", s->stream.sent_bytes_on_this_connection_per_type[STREAM_TRAFFIC_TYPE_DYNCFG]);
}
buffer_json_object_close(wb); // traffic
buffer_json_member_add_array(wb, "candidates");
struct rrdpush_destinations *d;
for (d = s->host->destinations; d; d = d->next) {
buffer_json_add_array_item_object(wb);
buffer_json_member_add_uint64(wb, "attempts", d->attempts);
{
if (d->ssl) {
snprintfz(buf, sizeof(buf) - 1, "%s:SSL", string2str(d->destination));
buffer_json_member_add_string(wb, "destination", buf);
}
else
buffer_json_member_add_string(wb, "destination", string2str(d->destination));
buffer_json_member_add_time_t(wb, "since", d->since);
buffer_json_member_add_time_t(wb, "age", s->now - d->since);
buffer_json_member_add_string(wb, "last_handshake", stream_handshake_error_to_string(d->reason));
if(d->postpone_reconnection_until > s->now) {
buffer_json_member_add_time_t(wb, "next_check", d->postpone_reconnection_until);
buffer_json_member_add_time_t(wb, "next_in", d->postpone_reconnection_until - s->now);
}
}
buffer_json_object_close(wb); // each candidate
}
buffer_json_array_close(wb); // candidates
}
buffer_json_object_close(wb); // destination
}
buffer_json_object_close(wb); // streaming
}
static void agent_capabilities_to_json(BUFFER *wb, RRDHOST *host, const char *key) {
buffer_json_member_add_array(wb, key);
struct capability *capas = aclk_get_node_instance_capas(host);
for(struct capability *capa = capas; capa->name ;capa++) {
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_string(wb, "name", capa->name);
buffer_json_member_add_uint64(wb, "version", capa->version);
buffer_json_member_add_boolean(wb, "enabled", capa->enabled);
}
buffer_json_object_close(wb);
}
buffer_json_array_close(wb);
freez(capas);
}
static inline void host_dyncfg_to_json_v2(BUFFER *wb, const char *key, RRDHOST_STATUS *s) {
buffer_json_member_add_object(wb, key);
{
buffer_json_member_add_string(wb, "status", rrdhost_dyncfg_status_to_string(s->dyncfg.status));
}
buffer_json_object_close(wb); // health
}
static inline void rrdhost_health_to_json_v2(BUFFER *wb, const char *key, RRDHOST_STATUS *s) {
buffer_json_member_add_object(wb, key);
{
buffer_json_member_add_string(wb, "status", rrdhost_health_status_to_string(s->health.status));
if (s->health.status == RRDHOST_HEALTH_STATUS_RUNNING) {
buffer_json_member_add_object(wb, "alerts");
{
buffer_json_member_add_uint64(wb, "critical", s->health.alerts.critical);
buffer_json_member_add_uint64(wb, "warning", s->health.alerts.warning);
buffer_json_member_add_uint64(wb, "clear", s->health.alerts.clear);
buffer_json_member_add_uint64(wb, "undefined", s->health.alerts.undefined);
buffer_json_member_add_uint64(wb, "uninitialized", s->health.alerts.uninitialized);
}
buffer_json_object_close(wb); // alerts
}
}
buffer_json_object_close(wb); // health
}
static void rrdcontext_to_json_v2_rrdhost(BUFFER *wb, RRDHOST *host, struct rrdcontext_to_json_v2_data *ctl, size_t node_id) {
buffer_json_add_array_item_object(wb); // this node
buffer_json_node_add_v2(wb, host, node_id, 0,
(ctl->mode & CONTEXTS_V2_AGENTS) && !(ctl->mode & CONTEXTS_V2_NODE_INSTANCES));
if(ctl->mode & (CONTEXTS_V2_NODES_INFO | CONTEXTS_V2_NODE_INSTANCES)) {
RRDHOST_STATUS s;
rrdhost_status(host, ctl->now, &s);
if (ctl->mode & (CONTEXTS_V2_NODES_INFO)) {
buffer_json_member_add_string(wb, "v", rrdhost_program_version(host));
host_labels2json(host, wb, "labels");
if (host->system_info) {
buffer_json_member_add_object(wb, "hw");
{
buffer_json_member_add_string_or_empty(wb, "architecture", host->system_info->architecture);
buffer_json_member_add_string_or_empty(wb, "cpu_frequency", host->system_info->host_cpu_freq);
buffer_json_member_add_string_or_empty(wb, "cpus", host->system_info->host_cores);
buffer_json_member_add_string_or_empty(wb, "memory", host->system_info->host_ram_total);
buffer_json_member_add_string_or_empty(wb, "disk_space", host->system_info->host_disk_space);
buffer_json_member_add_string_or_empty(wb, "virtualization", host->system_info->virtualization);
buffer_json_member_add_string_or_empty(wb, "container", host->system_info->container);
}
buffer_json_object_close(wb);
buffer_json_member_add_object(wb, "os");
{
buffer_json_member_add_string_or_empty(wb, "id", host->system_info->host_os_id);
buffer_json_member_add_string_or_empty(wb, "nm", host->system_info->host_os_name);
buffer_json_member_add_string_or_empty(wb, "v", host->system_info->host_os_version);
buffer_json_member_add_object(wb, "kernel");
buffer_json_member_add_string_or_empty(wb, "nm", host->system_info->kernel_name);
buffer_json_member_add_string_or_empty(wb, "v", host->system_info->kernel_version);
buffer_json_object_close(wb);
}
buffer_json_object_close(wb);
}
// created - the node is created but never connected to cloud
// unreachable - not currently connected
// stale - connected but not having live data
// reachable - connected with live data
// pruned - not connected for some time and has been removed
buffer_json_member_add_string(wb, "state", rrdhost_state_cloud_emulation(host) ? "reachable" : "stale");
rrdhost_health_to_json_v2(wb, "health", &s);
agent_capabilities_to_json(wb, host, "capabilities");
}
if (ctl->mode & (CONTEXTS_V2_NODE_INSTANCES)) {
buffer_json_member_add_array(wb, "instances");
buffer_json_add_array_item_object(wb); // this instance
{
buffer_json_agent_status_id(wb, 0, 0);
buffer_json_member_add_object(wb, "db");
{
buffer_json_member_add_string(wb, "status", rrdhost_db_status_to_string(s.db.status));
buffer_json_member_add_string(wb, "liveness", rrdhost_db_liveness_to_string(s.db.liveness));
buffer_json_member_add_string(wb, "mode", rrd_memory_mode_name(s.db.mode));
buffer_json_member_add_time_t(wb, "first_time", s.db.first_time_s);
buffer_json_member_add_time_t(wb, "last_time", s.db.last_time_s);
buffer_json_member_add_uint64(wb, "metrics", s.db.metrics);
buffer_json_member_add_uint64(wb, "instances", s.db.instances);
buffer_json_member_add_uint64(wb, "contexts", s.db.contexts);
}
buffer_json_object_close(wb);
rrdhost_receiver_to_json(wb, &s, "ingest");
rrdhost_sender_to_json(wb, &s, "stream");
buffer_json_member_add_object(wb, "ml");
buffer_json_member_add_string(wb, "status", rrdhost_ml_status_to_string(s.ml.status));
buffer_json_member_add_string(wb, "type", rrdhost_ml_type_to_string(s.ml.type));
if (s.ml.status == RRDHOST_ML_STATUS_RUNNING) {
buffer_json_member_add_object(wb, "metrics");
{
buffer_json_member_add_uint64(wb, "anomalous", s.ml.metrics.anomalous);
buffer_json_member_add_uint64(wb, "normal", s.ml.metrics.normal);
buffer_json_member_add_uint64(wb, "trained", s.ml.metrics.trained);
buffer_json_member_add_uint64(wb, "pending", s.ml.metrics.pending);
buffer_json_member_add_uint64(wb, "silenced", s.ml.metrics.silenced);
}
buffer_json_object_close(wb); // metrics
}
buffer_json_object_close(wb); // ml
rrdhost_health_to_json_v2(wb, "health", &s);
host_functions2json(host, wb); // functions
agent_capabilities_to_json(wb, host, "capabilities");
host_dyncfg_to_json_v2(wb, "dyncfg", &s);
}
buffer_json_object_close(wb); // this instance
buffer_json_array_close(wb); // instances
}
}
buffer_json_object_close(wb); // this node
}
static ssize_t rrdcontext_to_json_v2_add_host(void *data, RRDHOST *host, bool queryable_host) {
if(!queryable_host || !host->rrdctx.contexts)
// the host matches the 'scope_host' but does not match the 'host' patterns
// or the host does not have any contexts
return 0; // continue to next host
struct rrdcontext_to_json_v2_data *ctl = data;
if(ctl->window.enabled && !rrdhost_matches_window(host, ctl->window.after, ctl->window.before, ctl->now))
// the host does not have data in the requested window
return 0; // continue to next host
if(ctl->request->timeout_ms && now_monotonic_usec() > ctl->timings.received_ut + ctl->request->timeout_ms * USEC_PER_MS)
// timed out
return -2; // stop the query
if(ctl->request->interrupt_callback && ctl->request->interrupt_callback(ctl->request->interrupt_callback_data))
// interrupted
return -1; // stop the query
bool host_matched = (ctl->mode & CONTEXTS_V2_NODES);
bool do_contexts = (ctl->mode & (CONTEXTS_V2_CONTEXTS | CONTEXTS_V2_ALERTS));
ctl->q.host_match = FTS_MATCHED_NONE;
if((ctl->mode & CONTEXTS_V2_SEARCH)) {
// check if we match the host itself
if(ctl->q.pattern && (
full_text_search_string(&ctl->q.fts, ctl->q.pattern, host->hostname) ||
full_text_search_char(&ctl->q.fts, ctl->q.pattern, host->machine_guid) ||
(ctl->q.pattern && full_text_search_char(&ctl->q.fts, ctl->q.pattern, ctl->q.host_node_id_str)))) {
ctl->q.host_match = FTS_MATCHED_HOST;
do_contexts = true;
}
}
if(do_contexts) {
// save it
SIMPLE_PATTERN *old_q = ctl->q.pattern;
if(ctl->q.host_match == FTS_MATCHED_HOST)
// do not do pattern matching on contexts - we matched the host itself
ctl->q.pattern = NULL;
ssize_t added = query_scope_foreach_context(
host, ctl->request->scope_contexts,
ctl->contexts.scope_pattern, ctl->contexts.pattern,
rrdcontext_to_json_v2_add_context, queryable_host, ctl);
// restore it
ctl->q.pattern = old_q;
if(unlikely(added < 0))
return -1; // stop the query
if(added)
host_matched = true;
}
if(!host_matched)
return 0;
if(ctl->mode & CONTEXTS_V2_FUNCTIONS) {
struct function_v2_entry t = {
.used = 1,
.size = 1,
.node_ids = &ctl->nodes.ni,
.help = NULL,
.tags = NULL,
.access = HTTP_ACCESS_ALL,
.priority = RRDFUNCTIONS_PRIORITY_DEFAULT,
};
host_functions_to_dict(host, ctl->functions.dict, &t, sizeof(t), &t.help, &t.tags, &t.access, &t.priority);
}
if(ctl->mode & CONTEXTS_V2_NODES) {
struct contexts_v2_node t = {
.ni = ctl->nodes.ni++,
.host = host,
};
dictionary_set(ctl->nodes.dict, host->machine_guid, &t, sizeof(struct contexts_v2_node));
}
return 1;
}
static void buffer_json_contexts_v2_mode_to_array(BUFFER *wb, const char *key, CONTEXTS_V2_MODE mode) {
buffer_json_member_add_array(wb, key);
if(mode & CONTEXTS_V2_VERSIONS)
buffer_json_add_array_item_string(wb, "versions");
if(mode & CONTEXTS_V2_AGENTS)
buffer_json_add_array_item_string(wb, "agents");
if(mode & CONTEXTS_V2_AGENTS_INFO)
buffer_json_add_array_item_string(wb, "agents-info");
if(mode & CONTEXTS_V2_NODES)
buffer_json_add_array_item_string(wb, "nodes");
if(mode & CONTEXTS_V2_NODES_INFO)
buffer_json_add_array_item_string(wb, "nodes-info");
if(mode & CONTEXTS_V2_NODE_INSTANCES)
buffer_json_add_array_item_string(wb, "nodes-instances");
if(mode & CONTEXTS_V2_CONTEXTS)
buffer_json_add_array_item_string(wb, "contexts");
if(mode & CONTEXTS_V2_SEARCH)
buffer_json_add_array_item_string(wb, "search");
if(mode & CONTEXTS_V2_ALERTS)
buffer_json_add_array_item_string(wb, "alerts");
if(mode & CONTEXTS_V2_ALERT_TRANSITIONS)
buffer_json_add_array_item_string(wb, "alert_transitions");
buffer_json_array_close(wb);
}
void buffer_json_query_timings(BUFFER *wb, const char *key, struct query_timings *timings) {
timings->finished_ut = now_monotonic_usec();
if(!timings->executed_ut)
timings->executed_ut = timings->finished_ut;
if(!timings->preprocessed_ut)
timings->preprocessed_ut = timings->received_ut;
buffer_json_member_add_object(wb, key);
buffer_json_member_add_double(wb, "prep_ms", (NETDATA_DOUBLE)(timings->preprocessed_ut - timings->received_ut) / USEC_PER_MS);
buffer_json_member_add_double(wb, "query_ms", (NETDATA_DOUBLE)(timings->executed_ut - timings->preprocessed_ut) / USEC_PER_MS);
buffer_json_member_add_double(wb, "output_ms", (NETDATA_DOUBLE)(timings->finished_ut - timings->executed_ut) / USEC_PER_MS);
buffer_json_member_add_double(wb, "total_ms", (NETDATA_DOUBLE)(timings->finished_ut - timings->received_ut) / USEC_PER_MS);
buffer_json_member_add_double(wb, "cloud_ms", (NETDATA_DOUBLE)(timings->finished_ut - timings->received_ut) / USEC_PER_MS);
buffer_json_object_close(wb);
}
void build_info_to_json_object(BUFFER *b);
void buffer_json_agents_v2(BUFFER *wb, struct query_timings *timings, time_t now_s, bool info, bool array) {
if(!now_s)
now_s = now_realtime_sec();
if(array) {
buffer_json_member_add_array(wb, "agents");
buffer_json_add_array_item_object(wb);
}
else
buffer_json_member_add_object(wb, "agent");
buffer_json_member_add_string(wb, "mg", localhost->machine_guid);
buffer_json_member_add_uuid(wb, "nd", localhost->node_id);
buffer_json_member_add_string(wb, "nm", rrdhost_hostname(localhost));
buffer_json_member_add_time_t(wb, "now", now_s);
if(array)
buffer_json_member_add_uint64(wb, "ai", 0);
if(info) {
buffer_json_member_add_object(wb, "application");
build_info_to_json_object(wb);
buffer_json_object_close(wb); // netdata
buffer_json_cloud_status(wb, now_s);
buffer_json_member_add_array(wb, "db_size");
for (size_t tier = 0; tier < storage_tiers; tier++) {
STORAGE_ENGINE *eng = localhost->db[tier].eng;
if (!eng) continue;
uint64_t max = storage_engine_disk_space_max(eng->seb, localhost->db[tier].si);
uint64_t used = storage_engine_disk_space_used(eng->seb, localhost->db[tier].si);
time_t first_time_s = storage_engine_global_first_time_s(eng->seb, localhost->db[tier].si);
size_t currently_collected_metrics = storage_engine_collected_metrics(eng->seb, localhost->db[tier].si);
NETDATA_DOUBLE percent;
if (used && max)
percent = (NETDATA_DOUBLE) used * 100.0 / (NETDATA_DOUBLE) max;
else
percent = 0.0;
buffer_json_add_array_item_object(wb);
buffer_json_member_add_uint64(wb, "tier", tier);
buffer_json_member_add_uint64(wb, "metrics", storage_engine_metrics(eng->seb, localhost->db[tier].si));
buffer_json_member_add_uint64(wb, "samples", storage_engine_samples(eng->seb, localhost->db[tier].si));
if(used || max) {
buffer_json_member_add_uint64(wb, "disk_used", used);
buffer_json_member_add_uint64(wb, "disk_max", max);
buffer_json_member_add_double(wb, "disk_percent", percent);
}
if(first_time_s) {
buffer_json_member_add_time_t(wb, "from", first_time_s);
buffer_json_member_add_time_t(wb, "to", now_s);
buffer_json_member_add_time_t(wb, "retention", now_s - first_time_s);
if(used || max) // we have disk space information
buffer_json_member_add_time_t(wb, "expected_retention",
(time_t) ((NETDATA_DOUBLE) (now_s - first_time_s) * 100.0 / percent));
}
if(currently_collected_metrics)
buffer_json_member_add_uint64(wb, "currently_collected_metrics", currently_collected_metrics);
buffer_json_object_close(wb);
}
buffer_json_array_close(wb); // db_size
}
if(timings)
buffer_json_query_timings(wb, "timings", timings);
buffer_json_object_close(wb);
if(array)
buffer_json_array_close(wb);
}
void buffer_json_cloud_timings(BUFFER *wb, const char *key, struct query_timings *timings) {
if(!timings->finished_ut)
timings->finished_ut = now_monotonic_usec();
buffer_json_member_add_object(wb, key);
buffer_json_member_add_double(wb, "routing_ms", 0.0);
buffer_json_member_add_double(wb, "node_max_ms", 0.0);
buffer_json_member_add_double(wb, "total_ms", (NETDATA_DOUBLE)(timings->finished_ut - timings->received_ut) / USEC_PER_MS);
buffer_json_object_close(wb);
}
static void functions_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused) {
struct function_v2_entry *t = value;
// it is initialized with a static reference - we need to mallocz() the array
size_t *v = t->node_ids;
t->node_ids = mallocz(sizeof(size_t));
*t->node_ids = *v;
t->size = 1;
t->used = 1;
}
static bool functions_conflict_callback(const DICTIONARY_ITEM *item __maybe_unused, void *old_value, void *new_value, void *data __maybe_unused) {
struct function_v2_entry *t = old_value, *n = new_value;
size_t *v = n->node_ids;
if(t->used >= t->size) {
t->node_ids = reallocz(t->node_ids, t->size * 2 * sizeof(size_t));
t->size *= 2;
}
t->node_ids[t->used++] = *v;
return true;
}
static void functions_delete_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused) {
struct function_v2_entry *t = value;
freez(t->node_ids);
}
static bool contexts_conflict_callback(const DICTIONARY_ITEM *item __maybe_unused, void *old_value, void *new_value, void *data __maybe_unused) {
struct context_v2_entry *o = old_value;
struct context_v2_entry *n = new_value;
o->count++;
if(o->family != n->family) {
if((o->flags & RRD_FLAG_COLLECTED) && !(n->flags & RRD_FLAG_COLLECTED))
// keep old
;
else if(!(o->flags & RRD_FLAG_COLLECTED) && (n->flags & RRD_FLAG_COLLECTED)) {
// keep new
string_freez(o->family);
o->family = string_dup(n->family);
}
else {
// merge
STRING *old_family = o->family;
o->family = string_2way_merge(o->family, n->family);
string_freez(old_family);
}
}
if(o->priority != n->priority) {
if((o->flags & RRD_FLAG_COLLECTED) && !(n->flags & RRD_FLAG_COLLECTED))
// keep o
;
else if(!(o->flags & RRD_FLAG_COLLECTED) && (n->flags & RRD_FLAG_COLLECTED))
// keep n
o->priority = n->priority;
else
// keep the min
o->priority = MIN(o->priority, n->priority);
}
if(o->first_time_s && n->first_time_s)
o->first_time_s = MIN(o->first_time_s, n->first_time_s);
else if(!o->first_time_s)
o->first_time_s = n->first_time_s;
if(o->last_time_s && n->last_time_s)
o->last_time_s = MAX(o->last_time_s, n->last_time_s);
else if(!o->last_time_s)
o->last_time_s = n->last_time_s;
o->flags |= n->flags;
o->match = MIN(o->match, n->match);
string_freez(n->family);
return true;
}
static void contexts_delete_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data __maybe_unused) {
struct context_v2_entry *z = value;
string_freez(z->family);
}
static void rrdcontext_v2_set_transition_filter(const char *machine_guid, const char *context, time_t alarm_id, void *data) {
struct rrdcontext_to_json_v2_data *ctl = data;
if(machine_guid && *machine_guid) {
if(ctl->nodes.scope_pattern)
simple_pattern_free(ctl->nodes.scope_pattern);
if(ctl->nodes.pattern)
simple_pattern_free(ctl->nodes.pattern);
ctl->nodes.scope_pattern = string_to_simple_pattern(machine_guid);
ctl->nodes.pattern = NULL;
}
if(context && *context) {
if(ctl->contexts.scope_pattern)
simple_pattern_free(ctl->contexts.scope_pattern);
if(ctl->contexts.pattern)
simple_pattern_free(ctl->contexts.pattern);
ctl->contexts.scope_pattern = string_to_simple_pattern(context);
ctl->contexts.pattern = NULL;
}
ctl->alerts.alarm_id_filter = alarm_id;
}
struct alert_instances_callback_data {
BUFFER *wb;
struct rrdcontext_to_json_v2_data *ctl;
bool debug;
};
static void contexts_v2_alert_config_to_json_from_sql_alert_config_data(struct sql_alert_config_data *t, void *data) {
struct alert_transitions_callback_data *d = data;
BUFFER *wb = d->wb;
bool debug = d->debug;
d->configs_added++;
if(d->only_one_config)
buffer_json_add_array_item_object(wb); // alert config
{
buffer_json_member_add_string(wb, "name", t->name);
buffer_json_member_add_uuid(wb, "config_hash_id", t->config_hash_id);
buffer_json_member_add_object(wb, "selectors");
{
bool is_template = t->selectors.on_template && *t->selectors.on_template ? true : false;
buffer_json_member_add_string(wb, "type", is_template ? "template" : "alarm");
buffer_json_member_add_string(wb, "on", is_template ? t->selectors.on_template : t->selectors.on_key);
buffer_json_member_add_string(wb, "families", t->selectors.families);
buffer_json_member_add_string(wb, "host_labels", t->selectors.host_labels);
buffer_json_member_add_string(wb, "chart_labels", t->selectors.chart_labels);
}
buffer_json_object_close(wb); // selectors
buffer_json_member_add_object(wb, "value"); // value
{
// buffer_json_member_add_string(wb, "every", t->value.every); // does not exist in Netdata Cloud
buffer_json_member_add_string(wb, "units", t->value.units);
buffer_json_member_add_uint64(wb, "update_every", t->value.update_every);
if (t->value.db.after || debug) {
buffer_json_member_add_object(wb, "db");
{
// buffer_json_member_add_string(wb, "lookup", t->value.db.lookup); // does not exist in Netdata Cloud
buffer_json_member_add_time_t(wb, "after", t->value.db.after);
buffer_json_member_add_time_t(wb, "before", t->value.db.before);
buffer_json_member_add_string(wb, "time_group_condition", alerts_group_conditions_id2txt(t->value.db.time_group_condition));
buffer_json_member_add_double(wb, "time_group_value", t->value.db.time_group_value);
buffer_json_member_add_string(wb, "dims_group", alerts_dims_grouping_id2group(t->value.db.dims_group));
buffer_json_member_add_string(wb, "data_source", alerts_data_source_id2source(t->value.db.data_source));
buffer_json_member_add_string(wb, "method", t->value.db.method);
buffer_json_member_add_string(wb, "dimensions", t->value.db.dimensions);
rrdr_options_to_buffer_json_array(wb, "options", (RRDR_OPTIONS)t->value.db.options);
}
buffer_json_object_close(wb); // db
}
if (t->value.calc || debug)
buffer_json_member_add_string(wb, "calc", t->value.calc);
}
buffer_json_object_close(wb); // value
if (t->status.warn || t->status.crit || debug) {
buffer_json_member_add_object(wb, "status"); // status
{
NETDATA_DOUBLE green = t->status.green ? str2ndd(t->status.green, NULL) : NAN;
NETDATA_DOUBLE red = t->status.red ? str2ndd(t->status.red, NULL) : NAN;
if (!isnan(green) || debug)
buffer_json_member_add_double(wb, "green", green);
if (!isnan(red) || debug)
buffer_json_member_add_double(wb, "red", red);
if (t->status.warn || debug)
buffer_json_member_add_string(wb, "warn", t->status.warn);
if (t->status.crit || debug)
buffer_json_member_add_string(wb, "crit", t->status.crit);
}
buffer_json_object_close(wb); // status
}
buffer_json_member_add_object(wb, "notification");
{
buffer_json_member_add_string(wb, "type", "agent");
buffer_json_member_add_string(wb, "exec", t->notification.exec ? t->notification.exec : NULL);
buffer_json_member_add_string(wb, "to", t->notification.to_key ? t->notification.to_key : string2str(localhost->health.health_default_recipient));
buffer_json_member_add_string(wb, "delay", t->notification.delay);
buffer_json_member_add_string(wb, "repeat", t->notification.repeat);
buffer_json_member_add_string(wb, "options", t->notification.options);
}
buffer_json_object_close(wb); // notification
buffer_json_member_add_string(wb, "class", t->classification);
buffer_json_member_add_string(wb, "component", t->component);
buffer_json_member_add_string(wb, "type", t->type);
buffer_json_member_add_string(wb, "info", t->info);
buffer_json_member_add_string(wb, "summary", t->summary);
// buffer_json_member_add_string(wb, "source", t->source); // moved to alert instance
}
if(d->only_one_config)
buffer_json_object_close(wb);
}
int contexts_v2_alert_config_to_json(struct web_client *w, const char *config_hash_id) {
struct alert_transitions_callback_data data = {
.wb = w->response.data,
.debug = false,
.only_one_config = false,
};
DICTIONARY *configs = dictionary_create(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE);
dictionary_set(configs, config_hash_id, NULL, 0);
buffer_flush(w->response.data);
buffer_json_initialize(w->response.data, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_DEFAULT);
int added = sql_get_alert_configuration(configs, contexts_v2_alert_config_to_json_from_sql_alert_config_data, &data, false);
buffer_json_finalize(w->response.data);
int ret = HTTP_RESP_OK;
if(added <= 0) {
buffer_flush(w->response.data);
w->response.data->content_type = CT_TEXT_PLAIN;
if(added < 0) {
buffer_strcat(w->response.data, "Failed to execute SQL query.");
ret = HTTP_RESP_INTERNAL_SERVER_ERROR;
}
else {
buffer_strcat(w->response.data, "Config is not found.");
ret = HTTP_RESP_NOT_FOUND;
}
}
return ret;
}
static int contexts_v2_alert_instance_to_json_callback(const DICTIONARY_ITEM *item __maybe_unused, void *value, void *data) {
struct sql_alert_instance_v2_entry *t = value;
struct alert_instances_callback_data *d = data;
struct rrdcontext_to_json_v2_data *ctl = d->ctl; (void)ctl;
bool debug = d->debug; (void)debug;
BUFFER *wb = d->wb;
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_uint64(wb, "ni", t->ni);
buffer_json_member_add_string(wb, "nm", string2str(t->name));
buffer_json_member_add_string(wb, "ch", string2str(t->chart_id));
buffer_json_member_add_string(wb, "ch_n", string2str(t->chart_name));
if(ctl->request->options & CONTEXT_V2_OPTION_ALERTS_WITH_SUMMARY)
buffer_json_member_add_uint64(wb, "ati", t->ati);
if(ctl->request->options & CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES) {
buffer_json_member_add_string(wb, "units", string2str(t->units));
buffer_json_member_add_string(wb, "fami", string2str(t->family));
buffer_json_member_add_string(wb, "info", string2str(t->info));
buffer_json_member_add_string(wb, "sum", string2str(t->summary));
buffer_json_member_add_string(wb, "ctx", string2str(t->context));
buffer_json_member_add_string(wb, "st", rrdcalc_status2string(t->status));
buffer_json_member_add_uuid(wb, "tr_i", &t->last_transition_id);
buffer_json_member_add_double(wb, "tr_v", t->last_status_change_value);
buffer_json_member_add_time_t(wb, "tr_t", t->last_status_change);
buffer_json_member_add_uuid(wb, "cfg", &t->config_hash_id);
buffer_json_member_add_string(wb, "src", string2str(t->source));
buffer_json_member_add_string(wb, "to", string2str(t->recipient));
buffer_json_member_add_string(wb, "tp", string2str(t->type));
buffer_json_member_add_string(wb, "cm", string2str(t->component));
buffer_json_member_add_string(wb, "cl", string2str(t->classification));
// Agent specific fields
buffer_json_member_add_uint64(wb, "gi", t->global_id);
// rrdcalc_flags_to_json_array (wb, "flags", t->flags);
}
if(ctl->request->options & CONTEXT_V2_OPTION_ALERTS_WITH_VALUES) {
// Netdata Cloud fetched these by querying the agents
buffer_json_member_add_double(wb, "v", t->value);
buffer_json_member_add_time_t(wb, "t", t->last_updated);
}
}
buffer_json_object_close(wb); // alert instance
return 1;
}
static void contexts_v2_alerts_by_x_update_prototypes(void *data, STRING *type, STRING *component, STRING *classification, STRING *recipient) {
struct rrdcontext_to_json_v2_data *ctl = data;
dictionary_set_advanced(ctl->alerts.by_type, string2str(type), (ssize_t)string_strlen(type), NULL, sizeof(struct alert_by_x_entry), NULL);
dictionary_set_advanced(ctl->alerts.by_component, string2str(component), (ssize_t)string_strlen(component), NULL, sizeof(struct alert_by_x_entry), NULL);
dictionary_set_advanced(ctl->alerts.by_classification, string2str(classification), (ssize_t)string_strlen(classification), NULL, sizeof(struct alert_by_x_entry), NULL);
dictionary_set_advanced(ctl->alerts.by_recipient, string2str(recipient), (ssize_t)string_strlen(recipient), NULL, sizeof(struct alert_by_x_entry), NULL);
}
static void contexts_v2_alerts_by_x_to_json(BUFFER *wb, DICTIONARY *dict, const char *key) {
buffer_json_member_add_array(wb, key);
{
struct alert_by_x_entry *b;
dfe_start_read(dict, b) {
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_string(wb, "name", b_dfe.name);
buffer_json_member_add_uint64(wb, "cr", b->running.counts.critical);
buffer_json_member_add_uint64(wb, "wr", b->running.counts.warning);
buffer_json_member_add_uint64(wb, "cl", b->running.counts.clear);
buffer_json_member_add_uint64(wb, "er", b->running.counts.error);
buffer_json_member_add_uint64(wb, "running", b->running.total);
buffer_json_member_add_uint64(wb, "running_silent", b->running.silent);
if(b->prototypes.available)
buffer_json_member_add_uint64(wb, "available", b->prototypes.available);
}
buffer_json_object_close(wb);
}
dfe_done(b);
}
buffer_json_array_close(wb);
}
static void contexts_v2_alert_instances_to_json(BUFFER *wb, const char *key, struct rrdcontext_to_json_v2_data *ctl, bool debug) {
buffer_json_member_add_array(wb, key);
{
struct alert_instances_callback_data data = {
.wb = wb,
.ctl = ctl,
.debug = debug,
};
dictionary_walkthrough_rw(ctl->alerts.alert_instances, DICTIONARY_LOCK_READ,
contexts_v2_alert_instance_to_json_callback, &data);
}
buffer_json_array_close(wb); // alerts_instances
}
static void contexts_v2_alerts_to_json(BUFFER *wb, struct rrdcontext_to_json_v2_data *ctl, bool debug) {
if(ctl->request->options & CONTEXT_V2_OPTION_ALERTS_WITH_SUMMARY) {
buffer_json_member_add_array(wb, "alerts");
{
struct alert_v2_entry *t;
dfe_start_read(ctl->alerts.summary, t)
{
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_uint64(wb, "ati", t->ati);
buffer_json_member_add_string(wb, "nm", string2str(t->name));
buffer_json_member_add_string(wb, "sum", string2str(t->summary));
buffer_json_member_add_uint64(wb, "cr", t->counts.critical);
buffer_json_member_add_uint64(wb, "wr", t->counts.warning);
buffer_json_member_add_uint64(wb, "cl", t->counts.clear);
buffer_json_member_add_uint64(wb, "er", t->counts.error);
buffer_json_member_add_uint64(wb, "in", t->instances);
buffer_json_member_add_uint64(wb, "nd", dictionary_entries(t->nodes));
buffer_json_member_add_uint64(wb, "cfg", dictionary_entries(t->configs));
}
buffer_json_object_close(wb); // alert name
}
dfe_done(t);
}
buffer_json_array_close(wb); // alerts
health_prototype_metadata_foreach(ctl, contexts_v2_alerts_by_x_update_prototypes);
contexts_v2_alerts_by_x_to_json(wb, ctl->alerts.by_type, "alerts_by_type");
contexts_v2_alerts_by_x_to_json(wb, ctl->alerts.by_component, "alerts_by_component");
contexts_v2_alerts_by_x_to_json(wb, ctl->alerts.by_classification, "alerts_by_classification");
contexts_v2_alerts_by_x_to_json(wb, ctl->alerts.by_recipient, "alerts_by_recipient");
contexts_v2_alerts_by_x_to_json(wb, ctl->alerts.by_module, "alerts_by_module");
}
if(ctl->request->options & (CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES|CONTEXT_V2_OPTION_ALERTS_WITH_VALUES)) {
contexts_v2_alert_instances_to_json(wb, "alert_instances", ctl, debug);
}
}
#define SQL_TRANSITION_DATA_SMALL_STRING (6 * 8)
#define SQL_TRANSITION_DATA_MEDIUM_STRING (12 * 8)
#define SQL_TRANSITION_DATA_BIG_STRING 512
struct sql_alert_transition_fixed_size {
usec_t global_id;
nd_uuid_t transition_id;
nd_uuid_t host_id;
nd_uuid_t config_hash_id;
uint32_t alarm_id;
char alert_name[SQL_TRANSITION_DATA_SMALL_STRING];
char chart[RRD_ID_LENGTH_MAX];
char chart_name[RRD_ID_LENGTH_MAX];
char chart_context[SQL_TRANSITION_DATA_MEDIUM_STRING];
char family[SQL_TRANSITION_DATA_SMALL_STRING];
char recipient[SQL_TRANSITION_DATA_MEDIUM_STRING];
char units[SQL_TRANSITION_DATA_SMALL_STRING];
char exec[SQL_TRANSITION_DATA_BIG_STRING];
char info[SQL_TRANSITION_DATA_BIG_STRING];
char summary[SQL_TRANSITION_DATA_BIG_STRING];
char classification[SQL_TRANSITION_DATA_SMALL_STRING];
char type[SQL_TRANSITION_DATA_SMALL_STRING];
char component[SQL_TRANSITION_DATA_SMALL_STRING];
time_t when_key;
time_t duration;
time_t non_clear_duration;
uint64_t flags;
time_t delay_up_to_timestamp;
time_t exec_run_timestamp;
int exec_code;
int new_status;
int old_status;
int delay;
time_t last_repeat;
NETDATA_DOUBLE new_value;
NETDATA_DOUBLE old_value;
char machine_guid[UUID_STR_LEN];
struct sql_alert_transition_fixed_size *next;
struct sql_alert_transition_fixed_size *prev;
};
static struct sql_alert_transition_fixed_size *contexts_v2_alert_transition_dup(struct sql_alert_transition_data *t, const char *machine_guid, struct sql_alert_transition_fixed_size *dst) {
struct sql_alert_transition_fixed_size *n = dst ? dst : mallocz(sizeof(*n));
n->global_id = t->global_id;
uuid_copy(n->transition_id, *t->transition_id);
uuid_copy(n->host_id, *t->host_id);
uuid_copy(n->config_hash_id, *t->config_hash_id);
n->alarm_id = t->alarm_id;
strncpyz(n->alert_name, t->alert_name ? t->alert_name : "", sizeof(n->alert_name) - 1);
strncpyz(n->chart, t->chart ? t->chart : "", sizeof(n->chart) - 1);
strncpyz(n->chart_name, t->chart_name ? t->chart_name : n->chart, sizeof(n->chart_name) - 1);
strncpyz(n->chart_context, t->chart_context ? t->chart_context : "", sizeof(n->chart_context) - 1);
strncpyz(n->family, t->family ? t->family : "", sizeof(n->family) - 1);
strncpyz(n->recipient, t->recipient ? t->recipient : "", sizeof(n->recipient) - 1);
strncpyz(n->units, t->units ? t->units : "", sizeof(n->units) - 1);
strncpyz(n->exec, t->exec ? t->exec : "", sizeof(n->exec) - 1);
strncpyz(n->info, t->info ? t->info : "", sizeof(n->info) - 1);
strncpyz(n->summary, t->summary ? t->summary : "", sizeof(n->summary) - 1);
strncpyz(n->classification, t->classification ? t->classification : "", sizeof(n->classification) - 1);
strncpyz(n->type, t->type ? t->type : "", sizeof(n->type) - 1);
strncpyz(n->component, t->component ? t->component : "", sizeof(n->component) - 1);
n->when_key = t->when_key;
n->duration = t->duration;
n->non_clear_duration = t->non_clear_duration;
n->flags = t->flags;
n->delay_up_to_timestamp = t->delay_up_to_timestamp;
n->exec_run_timestamp = t->exec_run_timestamp;
n->exec_code = t->exec_code;
n->new_status = t->new_status;
n->old_status = t->old_status;
n->delay = t->delay;
n->last_repeat = t->last_repeat;
n->new_value = t->new_value;
n->old_value = t->old_value;
memcpy(n->machine_guid, machine_guid, sizeof(n->machine_guid));
n->next = n->prev = NULL;
return n;
}
static void contexts_v2_alert_transition_free(struct sql_alert_transition_fixed_size *t) {
freez(t);
}
static inline void contexts_v2_alert_transition_keep(struct alert_transitions_callback_data *d, struct sql_alert_transition_data *t, const char *machine_guid) {
d->items_matched++;
if(unlikely(t->global_id <= d->ctl->request->alerts.global_id_anchor)) {
// this is in our past, we are not interested
d->operations.skips_before++;
return;
}
if(unlikely(!d->base)) {
d->last_added = contexts_v2_alert_transition_dup(t, machine_guid, NULL);
DOUBLE_LINKED_LIST_APPEND_ITEM_UNSAFE(d->base, d->last_added, prev, next);
d->items_to_return++;
d->operations.first++;
return;
}
struct sql_alert_transition_fixed_size *last = d->last_added;
while(last->prev != d->base->prev && t->global_id > last->prev->global_id) {
last = last->prev;
d->operations.backwards++;
}
while(last->next && t->global_id < last->next->global_id) {
last = last->next;
d->operations.forwards++;
}
if(d->items_to_return >= d->max_items_to_return) {
if(last == d->base->prev && t->global_id < last->global_id) {
d->operations.skips_after++;
return;
}
}
d->items_to_return++;
if(t->global_id > last->global_id) {
if(d->items_to_return > d->max_items_to_return) {
d->items_to_return--;
d->operations.shifts++;
d->last_added = d->base->prev;
DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(d->base, d->last_added, prev, next);
d->last_added = contexts_v2_alert_transition_dup(t, machine_guid, d->last_added);
}
DOUBLE_LINKED_LIST_PREPEND_ITEM_UNSAFE(d->base, d->last_added, prev, next);
d->operations.prepend++;
}
else {
d->last_added = contexts_v2_alert_transition_dup(t, machine_guid, NULL);
DOUBLE_LINKED_LIST_APPEND_ITEM_UNSAFE(d->base, d->last_added, prev, next);
d->operations.append++;
}
while(d->items_to_return > d->max_items_to_return) {
// we have to remove something
struct sql_alert_transition_fixed_size *tmp = d->base->prev;
DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(d->base, tmp, prev, next);
d->items_to_return--;
if(unlikely(d->last_added == tmp))
d->last_added = d->base;
contexts_v2_alert_transition_free(tmp);
d->operations.shifts++;
}
}
static void contexts_v2_alert_transition_callback(struct sql_alert_transition_data *t, void *data) {
struct alert_transitions_callback_data *d = data;
d->items_evaluated++;
char machine_guid[UUID_STR_LEN] = "";
uuid_unparse_lower(*t->host_id, machine_guid);
const char *facets[ATF_TOTAL_ENTRIES] = {
[ATF_STATUS] = rrdcalc_status2string(t->new_status),
[ATF_CLASS] = t->classification,
[ATF_TYPE] = t->type,
[ATF_COMPONENT] = t->component,
[ATF_ROLE] = t->recipient && *t->recipient ? t->recipient : string2str(localhost->health.health_default_recipient),
[ATF_NODE] = machine_guid,
[ATF_ALERT_NAME] = t->alert_name,
[ATF_CHART_NAME] = t->chart_name,
[ATF_CONTEXT] = t->chart_context,
};
for(size_t i = 0; i < ATF_TOTAL_ENTRIES ;i++) {
if (!facets[i] || !*facets[i]) facets[i] = "unknown";
struct facet_entry tmp = {
.count = 0,
};
dictionary_set(d->facets[i].dict, facets[i], &tmp, sizeof(tmp));
}
bool selected[ATF_TOTAL_ENTRIES] = { 0 };
uint32_t selected_by = 0;
for(size_t i = 0; i < ATF_TOTAL_ENTRIES ;i++) {
selected[i] = !d->facets[i].pattern || simple_pattern_matches(d->facets[i].pattern, facets[i]);
if(selected[i])
selected_by++;
}
if(selected_by == ATF_TOTAL_ENTRIES) {
// this item is selected by all facets
// put it in our result (if it fits)
contexts_v2_alert_transition_keep(d, t, machine_guid);
}
if(selected_by >= ATF_TOTAL_ENTRIES - 1) {
// this item is selected by all, or all except one facet
// in both cases we need to add it to our counters
for (size_t i = 0; i < ATF_TOTAL_ENTRIES; i++) {
uint32_t counted_by = selected_by;
if (counted_by != ATF_TOTAL_ENTRIES) {
counted_by = 0;
for (size_t j = 0; j < ATF_TOTAL_ENTRIES; j++) {
if (i == j || selected[j])
counted_by++;
}
}
if (counted_by == ATF_TOTAL_ENTRIES) {
// we need to count it on this facet
struct facet_entry *x = dictionary_get(d->facets[i].dict, facets[i]);
internal_fatal(!x, "facet is not found");
if(x)
x->count++;
}
}
}
}
static void contexts_v2_alert_transitions_to_json(BUFFER *wb, struct rrdcontext_to_json_v2_data *ctl, bool debug) {
struct alert_transitions_callback_data data = {
.wb = wb,
.ctl = ctl,
.debug = debug,
.only_one_config = true,
.max_items_to_return = ctl->request->alerts.last,
.items_to_return = 0,
.base = NULL,
};
for(size_t i = 0; i < ATF_TOTAL_ENTRIES ;i++) {
data.facets[i].dict = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_FIXED_SIZE | DICT_OPTION_DONT_OVERWRITE_VALUE, NULL, sizeof(struct facet_entry));
if(ctl->request->alerts.facets[i])
data.facets[i].pattern = simple_pattern_create(ctl->request->alerts.facets[i], ",|", SIMPLE_PATTERN_EXACT, false);
}
sql_alert_transitions(
ctl->nodes.dict,
ctl->window.after,
ctl->window.before,
ctl->request->contexts,
ctl->request->alerts.alert,
ctl->request->alerts.transition,
contexts_v2_alert_transition_callback,
&data,
debug);
buffer_json_member_add_array(wb, "facets");
for (size_t i = 0; i < ATF_TOTAL_ENTRIES; i++) {
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_string(wb, "id", alert_transition_facets[i].id);
buffer_json_member_add_string(wb, "name", alert_transition_facets[i].name);
buffer_json_member_add_uint64(wb, "order", alert_transition_facets[i].order);
buffer_json_member_add_array(wb, "options");
{
struct facet_entry *x;
dfe_start_read(data.facets[i].dict, x) {
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_string(wb, "id", x_dfe.name);
if (i == ATF_NODE) {
RRDHOST *host = rrdhost_find_by_guid(x_dfe.name);
if (host)
buffer_json_member_add_string(wb, "name", rrdhost_hostname(host));
else
buffer_json_member_add_string(wb, "name", x_dfe.name);
} else
buffer_json_member_add_string(wb, "name", x_dfe.name);
buffer_json_member_add_uint64(wb, "count", x->count);
}
buffer_json_object_close(wb);
}
dfe_done(x);
}
buffer_json_array_close(wb); // options
}
buffer_json_object_close(wb); // facet
}
buffer_json_array_close(wb); // facets
buffer_json_member_add_array(wb, "transitions");
for(struct sql_alert_transition_fixed_size *t = data.base; t ; t = t->next) {
buffer_json_add_array_item_object(wb);
{
RRDHOST *host = rrdhost_find_by_guid(t->machine_guid);
buffer_json_member_add_uint64(wb, "gi", t->global_id);
buffer_json_member_add_uuid(wb, "transition_id", &t->transition_id);
buffer_json_member_add_uuid(wb, "config_hash_id", &t->config_hash_id);
buffer_json_member_add_string(wb, "machine_guid", t->machine_guid);
if(host) {
buffer_json_member_add_string(wb, "hostname", rrdhost_hostname(host));
if(host->node_id)
buffer_json_member_add_uuid(wb, "node_id", host->node_id);
}
buffer_json_member_add_string(wb, "alert", *t->alert_name ? t->alert_name : NULL);
buffer_json_member_add_string(wb, "instance", *t->chart ? t->chart : NULL);
buffer_json_member_add_string(wb, "instance_n", *t->chart_name ? t->chart_name : NULL);
buffer_json_member_add_string(wb, "context", *t->chart_context ? t->chart_context : NULL);
// buffer_json_member_add_string(wb, "family", *t->family ? t->family : NULL);
buffer_json_member_add_string(wb, "component", *t->component ? t->component : NULL);
buffer_json_member_add_string(wb, "classification", *t->classification ? t->classification : NULL);
buffer_json_member_add_string(wb, "type", *t->type ? t->type : NULL);
buffer_json_member_add_time_t(wb, "when", t->when_key);
buffer_json_member_add_string(wb, "info", *t->info ? t->info : "");
buffer_json_member_add_string(wb, "summary", *t->summary ? t->summary : "");
buffer_json_member_add_string(wb, "units", *t->units ? t->units : NULL);
buffer_json_member_add_object(wb, "new");
{
buffer_json_member_add_string(wb, "status", rrdcalc_status2string(t->new_status));
buffer_json_member_add_double(wb, "value", t->new_value);
}
buffer_json_object_close(wb); // new
buffer_json_member_add_object(wb, "old");
{
buffer_json_member_add_string(wb, "status", rrdcalc_status2string(t->old_status));
buffer_json_member_add_double(wb, "value", t->old_value);
buffer_json_member_add_time_t(wb, "duration", t->duration);
buffer_json_member_add_time_t(wb, "raised_duration", t->non_clear_duration);
}
buffer_json_object_close(wb); // old
buffer_json_member_add_object(wb, "notification");
{
buffer_json_member_add_time_t(wb, "when", t->exec_run_timestamp);
buffer_json_member_add_time_t(wb, "delay", t->delay);
buffer_json_member_add_time_t(wb, "delay_up_to_time", t->delay_up_to_timestamp);
health_entry_flags_to_json_array(wb, "flags", t->flags);
buffer_json_member_add_string(wb, "exec", *t->exec ? t->exec : string2str(localhost->health.health_default_exec));
buffer_json_member_add_uint64(wb, "exec_code", t->exec_code);
buffer_json_member_add_string(wb, "to", *t->recipient ? t->recipient : string2str(localhost->health.health_default_recipient));
}
buffer_json_object_close(wb); // notification
}
buffer_json_object_close(wb); // a transition
}
buffer_json_array_close(wb); // all transitions
if(ctl->options & CONTEXT_V2_OPTION_ALERTS_WITH_CONFIGURATIONS) {
DICTIONARY *configs = dictionary_create(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE);
for(struct sql_alert_transition_fixed_size *t = data.base; t ; t = t->next) {
char guid[UUID_STR_LEN];
uuid_unparse_lower(t->config_hash_id, guid);
dictionary_set(configs, guid, NULL, 0);
}
buffer_json_member_add_array(wb, "configurations");
sql_get_alert_configuration(configs, contexts_v2_alert_config_to_json_from_sql_alert_config_data, &data, debug);
buffer_json_array_close(wb);
dictionary_destroy(configs);
}
while(data.base) {
struct sql_alert_transition_fixed_size *t = data.base;
DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(data.base, t, prev, next);
contexts_v2_alert_transition_free(t);
}
for(size_t i = 0; i < ATF_TOTAL_ENTRIES ;i++) {
dictionary_destroy(data.facets[i].dict);
simple_pattern_free(data.facets[i].pattern);
}
buffer_json_member_add_object(wb, "items");
{
// all the items in the window, under the scope_nodes, ignoring the facets (filters)
buffer_json_member_add_uint64(wb, "evaluated", data.items_evaluated);
// all the items matching the query (if you didn't put anchor_gi and last, these are all the items you would get back)
buffer_json_member_add_uint64(wb, "matched", data.items_matched);
// the items included in this response
buffer_json_member_add_uint64(wb, "returned", data.items_to_return);
// same as last=X parameter
buffer_json_member_add_uint64(wb, "max_to_return", data.max_items_to_return);
// items before the first returned, this should be 0 if anchor_gi is not set
buffer_json_member_add_uint64(wb, "before", data.operations.skips_before);
// items after the last returned, when this is zero there aren't any items after the current list
buffer_json_member_add_uint64(wb, "after", data.operations.skips_after + data.operations.shifts);
}
buffer_json_object_close(wb); // items
if(debug) {
buffer_json_member_add_object(wb, "stats");
{
buffer_json_member_add_uint64(wb, "first", data.operations.first);
buffer_json_member_add_uint64(wb, "prepend", data.operations.prepend);
buffer_json_member_add_uint64(wb, "append", data.operations.append);
buffer_json_member_add_uint64(wb, "backwards", data.operations.backwards);
buffer_json_member_add_uint64(wb, "forwards", data.operations.forwards);
buffer_json_member_add_uint64(wb, "shifts", data.operations.shifts);
buffer_json_member_add_uint64(wb, "skips_before", data.operations.skips_before);
buffer_json_member_add_uint64(wb, "skips_after", data.operations.skips_after);
}
buffer_json_object_close(wb);
}
}
int rrdcontext_to_json_v2(BUFFER *wb, struct api_v2_contexts_request *req, CONTEXTS_V2_MODE mode) {
int resp = HTTP_RESP_OK;
bool run = true;
if(mode & CONTEXTS_V2_SEARCH)
mode |= CONTEXTS_V2_CONTEXTS;
if(mode & (CONTEXTS_V2_AGENTS_INFO))
mode |= CONTEXTS_V2_AGENTS;
if(mode & (CONTEXTS_V2_FUNCTIONS | CONTEXTS_V2_CONTEXTS | CONTEXTS_V2_SEARCH | CONTEXTS_V2_NODES_INFO | CONTEXTS_V2_NODE_INSTANCES))
mode |= CONTEXTS_V2_NODES;
if(mode & CONTEXTS_V2_ALERTS) {
mode |= CONTEXTS_V2_NODES;
req->options &= ~CONTEXT_V2_OPTION_ALERTS_WITH_CONFIGURATIONS;
if(!(req->options & (CONTEXT_V2_OPTION_ALERTS_WITH_SUMMARY|CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES|CONTEXT_V2_OPTION_ALERTS_WITH_VALUES)))
req->options |= CONTEXT_V2_OPTION_ALERTS_WITH_SUMMARY;
}
if(mode & CONTEXTS_V2_ALERT_TRANSITIONS) {
mode |= CONTEXTS_V2_NODES;
req->options &= ~CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES;
}
struct rrdcontext_to_json_v2_data ctl = {
.wb = wb,
.request = req,
.mode = mode,
.options = req->options,
.versions = { 0 },
.nodes.scope_pattern = string_to_simple_pattern(req->scope_nodes),
.nodes.pattern = string_to_simple_pattern(req->nodes),
.contexts.pattern = string_to_simple_pattern(req->contexts),
.contexts.scope_pattern = string_to_simple_pattern(req->scope_contexts),
.q.pattern = string_to_simple_pattern_nocase(req->q),
.alerts.alert_name_pattern = string_to_simple_pattern(req->alerts.alert),
.window = {
.enabled = false,
.relative = false,
.after = req->after,
.before = req->before,
},
.timings = {
.received_ut = now_monotonic_usec(),
}
};
bool debug = ctl.options & CONTEXT_V2_OPTION_DEBUG;
if(mode & CONTEXTS_V2_NODES) {
ctl.nodes.dict = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct contexts_v2_node));
}
if(mode & CONTEXTS_V2_CONTEXTS) {
ctl.contexts.dict = dictionary_create_advanced(
DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL,
sizeof(struct context_v2_entry));
dictionary_register_conflict_callback(ctl.contexts.dict, contexts_conflict_callback, &ctl);
dictionary_register_delete_callback(ctl.contexts.dict, contexts_delete_callback, &ctl);
}
if(mode & CONTEXTS_V2_FUNCTIONS) {
ctl.functions.dict = dictionary_create_advanced(
DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL,
sizeof(struct function_v2_entry));
dictionary_register_insert_callback(ctl.functions.dict, functions_insert_callback, &ctl);
dictionary_register_conflict_callback(ctl.functions.dict, functions_conflict_callback, &ctl);
dictionary_register_delete_callback(ctl.functions.dict, functions_delete_callback, &ctl);
}
if(mode & CONTEXTS_V2_ALERTS) {
if(req->alerts.transition) {
ctl.options |= CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES|CONTEXT_V2_OPTION_ALERTS_WITH_VALUES;
run = sql_find_alert_transition(req->alerts.transition, rrdcontext_v2_set_transition_filter, &ctl);
if(!run) {
resp = HTTP_RESP_NOT_FOUND;
goto cleanup;
}
}
ctl.alerts.summary = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct alert_v2_entry));
dictionary_register_insert_callback(ctl.alerts.summary, alerts_v2_insert_callback, &ctl);
dictionary_register_conflict_callback(ctl.alerts.summary, alerts_v2_conflict_callback, &ctl);
dictionary_register_delete_callback(ctl.alerts.summary, alerts_v2_delete_callback, &ctl);
ctl.alerts.by_type = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct alert_by_x_entry));
dictionary_register_insert_callback(ctl.alerts.by_type, alerts_by_x_insert_callback, NULL);
dictionary_register_conflict_callback(ctl.alerts.by_type, alerts_by_x_conflict_callback, NULL);
ctl.alerts.by_component = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct alert_by_x_entry));
dictionary_register_insert_callback(ctl.alerts.by_component, alerts_by_x_insert_callback, NULL);
dictionary_register_conflict_callback(ctl.alerts.by_component, alerts_by_x_conflict_callback, NULL);
ctl.alerts.by_classification = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct alert_by_x_entry));
dictionary_register_insert_callback(ctl.alerts.by_classification, alerts_by_x_insert_callback, NULL);
dictionary_register_conflict_callback(ctl.alerts.by_classification, alerts_by_x_conflict_callback, NULL);
ctl.alerts.by_recipient = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct alert_by_x_entry));
dictionary_register_insert_callback(ctl.alerts.by_recipient, alerts_by_x_insert_callback, NULL);
dictionary_register_conflict_callback(ctl.alerts.by_recipient, alerts_by_x_conflict_callback, NULL);
ctl.alerts.by_module = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct alert_by_x_entry));
dictionary_register_insert_callback(ctl.alerts.by_module, alerts_by_x_insert_callback, NULL);
dictionary_register_conflict_callback(ctl.alerts.by_module, alerts_by_x_conflict_callback, NULL);
if(ctl.options & (CONTEXT_V2_OPTION_ALERTS_WITH_INSTANCES | CONTEXT_V2_OPTION_ALERTS_WITH_VALUES)) {
ctl.alerts.alert_instances = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE,
NULL, sizeof(struct sql_alert_instance_v2_entry));
dictionary_register_insert_callback(ctl.alerts.alert_instances, alert_instances_v2_insert_callback, &ctl);
dictionary_register_conflict_callback(ctl.alerts.alert_instances, alert_instances_v2_conflict_callback, &ctl);
dictionary_register_delete_callback(ctl.alerts.alert_instances, alert_instances_delete_callback, &ctl);
}
}
if(req->after || req->before) {
ctl.window.relative = rrdr_relative_window_to_absolute_query(&ctl.window.after, &ctl.window.before, &ctl.now
, false
);
ctl.window.enabled = !(mode & CONTEXTS_V2_ALERT_TRANSITIONS);
}
else
ctl.now = now_realtime_sec();
buffer_json_initialize(wb, "\"", "\"", 0, true,
((req->options & CONTEXT_V2_OPTION_MINIFY) && !(req->options & CONTEXT_V2_OPTION_DEBUG)) ? BUFFER_JSON_OPTIONS_MINIFY : BUFFER_JSON_OPTIONS_DEFAULT);
buffer_json_member_add_uint64(wb, "api", 2);
if(req->options & CONTEXT_V2_OPTION_DEBUG) {
buffer_json_member_add_object(wb, "request");
{
buffer_json_contexts_v2_mode_to_array(wb, "mode", mode);
web_client_api_request_v2_contexts_options_to_buffer_json_array(wb, "options", req->options);
buffer_json_member_add_object(wb, "scope");
{
buffer_json_member_add_string(wb, "scope_nodes", req->scope_nodes);
if (mode & (CONTEXTS_V2_CONTEXTS | CONTEXTS_V2_SEARCH | CONTEXTS_V2_ALERTS))
buffer_json_member_add_string(wb, "scope_contexts", req->scope_contexts);
}
buffer_json_object_close(wb);
buffer_json_member_add_object(wb, "selectors");
{
buffer_json_member_add_string(wb, "nodes", req->nodes);
if (mode & (CONTEXTS_V2_CONTEXTS | CONTEXTS_V2_SEARCH | CONTEXTS_V2_ALERTS))
buffer_json_member_add_string(wb, "contexts", req->contexts);
if(mode & (CONTEXTS_V2_ALERTS | CONTEXTS_V2_ALERT_TRANSITIONS)) {
buffer_json_member_add_object(wb, "alerts");
if(mode & CONTEXTS_V2_ALERTS)
web_client_api_request_v2_contexts_alerts_status_to_buffer_json_array(wb, "status", req->alerts.status);
if(mode & CONTEXTS_V2_ALERT_TRANSITIONS) {
buffer_json_member_add_string(wb, "context", req->contexts);
buffer_json_member_add_uint64(wb, "anchor_gi", req->alerts.global_id_anchor);
buffer_json_member_add_uint64(wb, "last", req->alerts.last);
}
buffer_json_member_add_string(wb, "alert", req->alerts.alert);
buffer_json_member_add_string(wb, "transition", req->alerts.transition);
buffer_json_object_close(wb); // alerts
}
}
buffer_json_object_close(wb); // selectors
buffer_json_member_add_object(wb, "filters");
{
if (mode & CONTEXTS_V2_SEARCH)
buffer_json_member_add_string(wb, "q", req->q);
buffer_json_member_add_time_t(wb, "after", req->after);
buffer_json_member_add_time_t(wb, "before", req->before);
}
buffer_json_object_close(wb); // filters
if(mode & CONTEXTS_V2_ALERT_TRANSITIONS) {
buffer_json_member_add_object(wb, "facets");
{
for (int i = 0; i < ATF_TOTAL_ENTRIES; i++) {
buffer_json_member_add_string(wb, alert_transition_facets[i].query_param, req->alerts.facets[i]);
}
}
buffer_json_object_close(wb); // facets
}
}
buffer_json_object_close(wb);
}
ssize_t ret = 0;
if(run)
ret = query_scope_foreach_host(ctl.nodes.scope_pattern, ctl.nodes.pattern,
rrdcontext_to_json_v2_add_host, &ctl,
&ctl.versions, ctl.q.host_node_id_str);
if(unlikely(ret < 0)) {
buffer_flush(wb);
if(ret == -2) {
buffer_strcat(wb, "query timeout");
resp = HTTP_RESP_GATEWAY_TIMEOUT;
}
else {
buffer_strcat(wb, "query interrupted");
resp = HTTP_RESP_CLIENT_CLOSED_REQUEST;
}
goto cleanup;
}
ctl.timings.executed_ut = now_monotonic_usec();
if(mode & CONTEXTS_V2_ALERT_TRANSITIONS) {
contexts_v2_alert_transitions_to_json(wb, &ctl, debug);
}
else {
if (mode & CONTEXTS_V2_NODES) {
buffer_json_member_add_array(wb, "nodes");
struct contexts_v2_node *t;
dfe_start_read(ctl.nodes.dict, t) {
rrdcontext_to_json_v2_rrdhost(wb, t->host, &ctl, t->ni);
}
dfe_done(t);
buffer_json_array_close(wb);
}
if (mode & CONTEXTS_V2_FUNCTIONS) {
buffer_json_member_add_array(wb, "functions");
{
struct function_v2_entry *t;
dfe_start_read(ctl.functions.dict, t) {
buffer_json_add_array_item_object(wb);
{
buffer_json_member_add_string(wb, "name", t_dfe.name);
buffer_json_member_add_string(wb, "help", string2str(t->help));
buffer_json_member_add_array(wb, "ni");
{
for (size_t i = 0; i < t->used; i++)
buffer_json_add_array_item_uint64(wb, t->node_ids[i]);
}
buffer_json_array_close(wb);
buffer_json_member_add_string(wb, "tags", string2str(t->tags));
http_access2buffer_json_array(wb, "access", t->access);
buffer_json_member_add_uint64(wb, "priority", t->priority);
}
buffer_json_object_close(wb);
}
dfe_done(t);
}
buffer_json_array_close(wb);
}
if (mode & CONTEXTS_V2_CONTEXTS) {
buffer_json_member_add_object(wb, "contexts");
{
struct context_v2_entry *z;
dfe_start_read(ctl.contexts.dict, z) {
bool collected = z->flags & RRD_FLAG_COLLECTED;
buffer_json_member_add_object(wb, string2str(z->id));
{
buffer_json_member_add_string(wb, "family", string2str(z->family));
buffer_json_member_add_uint64(wb, "priority", z->priority);
buffer_json_member_add_time_t(wb, "first_entry", z->first_time_s);
buffer_json_member_add_time_t(wb, "last_entry", collected ? ctl.now : z->last_time_s);
buffer_json_member_add_boolean(wb, "live", collected);
if (mode & CONTEXTS_V2_SEARCH)
buffer_json_member_add_string(wb, "match", fts_match_to_string(z->match));
}
buffer_json_object_close(wb);
}
dfe_done(z);
}
buffer_json_object_close(wb); // contexts
}
if (mode & CONTEXTS_V2_ALERTS)
contexts_v2_alerts_to_json(wb, &ctl, debug);
if (mode & CONTEXTS_V2_SEARCH) {
buffer_json_member_add_object(wb, "searches");
{
buffer_json_member_add_uint64(wb, "strings", ctl.q.fts.string_searches);
buffer_json_member_add_uint64(wb, "char", ctl.q.fts.char_searches);
buffer_json_member_add_uint64(wb, "total", ctl.q.fts.searches);
}
buffer_json_object_close(wb);
}
if (mode & (CONTEXTS_V2_VERSIONS))
version_hashes_api_v2(wb, &ctl.versions);
if (mode & CONTEXTS_V2_AGENTS)
buffer_json_agents_v2(wb, &ctl.timings, ctl.now, mode & (CONTEXTS_V2_AGENTS_INFO), true);
}
buffer_json_cloud_timings(wb, "timings", &ctl.timings);
buffer_json_finalize(wb);
cleanup:
dictionary_destroy(ctl.nodes.dict);
dictionary_destroy(ctl.contexts.dict);
dictionary_destroy(ctl.functions.dict);
dictionary_destroy(ctl.alerts.summary);
dictionary_destroy(ctl.alerts.alert_instances);
dictionary_destroy(ctl.alerts.by_type);
dictionary_destroy(ctl.alerts.by_component);
dictionary_destroy(ctl.alerts.by_classification);
dictionary_destroy(ctl.alerts.by_recipient);
dictionary_destroy(ctl.alerts.by_module);
simple_pattern_free(ctl.nodes.scope_pattern);
simple_pattern_free(ctl.nodes.pattern);
simple_pattern_free(ctl.contexts.pattern);
simple_pattern_free(ctl.contexts.scope_pattern);
simple_pattern_free(ctl.q.pattern);
simple_pattern_free(ctl.alerts.alert_name_pattern);
return resp;
}