diff options
Diffstat (limited to '')
-rw-r--r-- | src/exporting/prometheus/prometheus.c | 1020 |
1 files changed, 1020 insertions, 0 deletions
diff --git a/src/exporting/prometheus/prometheus.c b/src/exporting/prometheus/prometheus.c new file mode 100644 index 000000000..0ba83a939 --- /dev/null +++ b/src/exporting/prometheus/prometheus.c @@ -0,0 +1,1020 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "prometheus.h" + +// ---------------------------------------------------------------------------- +// PROMETHEUS +// /api/v1/allmetrics?format=prometheus and /api/v1/allmetrics?format=prometheus_all_hosts + +static int is_matches_rrdset(struct instance *instance, RRDSET *st, SIMPLE_PATTERN *filter) { + if (instance->config.options & EXPORTING_OPTION_SEND_NAMES) { + return simple_pattern_matches_string(filter, st->name); + } + return simple_pattern_matches_string(filter, st->id); +} + +/** + * Check if a chart can be sent to Prometheus + * + * @param instance an instance data structure. + * @param st a chart. + * @param filter a simple pattern to match against. + * @return Returns 1 if the chart can be sent, 0 otherwise. + */ +inline int can_send_rrdset(struct instance *instance, RRDSET *st, SIMPLE_PATTERN *filter) +{ +#ifdef NETDATA_INTERNAL_CHECKS + RRDHOST *host = st->rrdhost; +#endif + + if (unlikely(rrdset_flag_check(st, RRDSET_FLAG_EXPORTING_IGNORE))) + return 0; + + if (filter) { + if (!is_matches_rrdset(instance, st, filter)) { + return 0; + } + } else if (unlikely(!rrdset_flag_check(st, RRDSET_FLAG_EXPORTING_SEND))) { + // we have not checked this chart + if (is_matches_rrdset(instance, st, instance->config.charts_pattern)) { + rrdset_flag_set(st, RRDSET_FLAG_EXPORTING_SEND); + } else { + rrdset_flag_set(st, RRDSET_FLAG_EXPORTING_IGNORE); + netdata_log_debug( + D_EXPORTING, + "EXPORTING: not sending chart '%s' of host '%s', because it is disabled for exporting.", + rrdset_id(st), + rrdhost_hostname(host)); + return 0; + } + } + + if (unlikely(!rrdset_is_available_for_exporting_and_alarms(st))) { + netdata_log_debug( + D_EXPORTING, + "EXPORTING: not sending chart '%s' of host '%s', because it is not available for exporting.", + rrdset_id(st), + rrdhost_hostname(host)); + return 0; + } + + if (unlikely( + st->rrd_memory_mode == RRD_MEMORY_MODE_NONE && + !(EXPORTING_OPTIONS_DATA_SOURCE(instance->config.options) == EXPORTING_SOURCE_DATA_AS_COLLECTED))) { + netdata_log_debug( + D_EXPORTING, + "EXPORTING: not sending chart '%s' of host '%s' because its memory mode is '%s' and the exporting connector requires database access.", + rrdset_id(st), + rrdhost_hostname(host), + rrd_memory_mode_name(host->rrd_memory_mode)); + return 0; + } + + return 1; +} + +static struct prometheus_server { + const char *server; + uint32_t hash; + RRDHOST *host; + time_t last_access; + struct prometheus_server *next; +} *prometheus_server_root = NULL; + +static netdata_mutex_t prometheus_server_root_mutex = NETDATA_MUTEX_INITIALIZER; + +/** + * Clean server root local structure + */ +void prometheus_clean_server_root() +{ + if (prometheus_server_root) { + netdata_mutex_lock(&prometheus_server_root_mutex); + + struct prometheus_server *ps; + for (ps = prometheus_server_root; ps; ) { + struct prometheus_server *current = ps; + ps = ps->next; + if(current->server) + freez((void *)current->server); + + freez(current); + } + prometheus_server_root = NULL; + netdata_mutex_unlock(&prometheus_server_root_mutex); + } +} + +/** + * Get the last time when a Prometheus server scraped the Netdata Prometheus exporter. + * + * @param server the name of the Prometheus server. + * @param host a data collecting host. + * @param now actual time. + * @return Returns the last time when the server accessed Netdata, or 0 if it is the first occurrence. + */ +static inline time_t prometheus_server_last_access(const char *server, RRDHOST *host, time_t now) +{ +#ifdef UNIT_TESTING + return 0; +#endif + uint32_t hash = simple_hash(server); + + netdata_mutex_lock(&prometheus_server_root_mutex); + + struct prometheus_server *ps; + for (ps = prometheus_server_root; ps; ps = ps->next) { + if (host == ps->host && hash == ps->hash && !strcmp(server, ps->server)) { + time_t last = ps->last_access; + ps->last_access = now; + netdata_mutex_unlock(&prometheus_server_root_mutex); + return last; + } + } + + ps = callocz(1, sizeof(struct prometheus_server)); + ps->server = strdupz(server); + ps->hash = hash; + ps->host = host; + ps->last_access = now; + ps->next = prometheus_server_root; + prometheus_server_root = ps; + + netdata_mutex_unlock(&prometheus_server_root_mutex); + return 0; +} + +/** + * Copy and sanitize name. + * + * @param d a destination string. + * @param s a source string. + * @param usable the number of characters to copy. + * @return Returns the length of the copied string. + */ +inline size_t prometheus_name_copy(char *d, const char *s, size_t usable) +{ + size_t n; + + for (n = 0; *s && n < usable; d++, s++, n++) { + register char c = *s; + + if (!isalnum(c)) + *d = '_'; + else + *d = c; + } + *d = '\0'; + + return n; +} + +/** + * Copy and sanitize label. + * + * @param d a destination string. + * @param s a source string. + * @param usable the number of characters to copy. + * @return Returns the length of the copied string. + */ +inline size_t prometheus_label_copy(char *d, const char *s, size_t usable) +{ + size_t n; + + // make sure we can escape one character without overflowing the buffer + usable--; + + for (n = 0; *s && n < usable; d++, s++, n++) { + register char c = *s; + + if (unlikely(c == '"' || c == '\\' || c == '\n')) { + *d++ = '\\'; + n++; + } + *d = c; + } + *d = '\0'; + + return n; +} + +/** + * Copy and sanitize units. + * + * @param d a destination string. + * @param s a source string. + * @param usable the number of characters to copy. + * @param showoldunits set this flag to 1 to show old (before v1.12) units. + * @return Returns the destination string. + */ +inline char *prometheus_units_copy(char *d, const char *s, size_t usable, int showoldunits) +{ + const char *sorig = s; + char *ret = d; + size_t n; + + // Fix for issue 5227 + if (unlikely(showoldunits)) { + static struct { + const char *newunit; + uint32_t hash; + const char *oldunit; + } units[] = { { "KiB/s", 0, "kilobytes/s" }, + { "MiB/s", 0, "MB/s" }, + { "GiB/s", 0, "GB/s" }, + { "KiB", 0, "KB" }, + { "MiB", 0, "MB" }, + { "GiB", 0, "GB" }, + { "inodes", 0, "Inodes" }, + { "percentage", 0, "percent" }, + { "faults/s", 0, "page faults/s" }, + { "KiB/operation", 0, "kilobytes per operation" }, + { "milliseconds/operation", 0, "ms per operation" }, + { NULL, 0, NULL } }; + static int initialized = 0; + int i; + + if (unlikely(!initialized)) { + for (i = 0; units[i].newunit; i++) + units[i].hash = simple_hash(units[i].newunit); + initialized = 1; + } + + uint32_t hash = simple_hash(s); + for (i = 0; units[i].newunit; i++) { + if (unlikely(hash == units[i].hash && !strcmp(s, units[i].newunit))) { + // netdata_log_info("matched extension for filename '%s': '%s'", filename, last_dot); + s = units[i].oldunit; + sorig = s; + break; + } + } + } + *d++ = '_'; + for (n = 1; *s && n < usable; d++, s++, n++) { + register char c = *s; + + if (!isalnum(c)) + *d = '_'; + else + *d = c; + } + + if (n == 2 && sorig[0] == '%') { + n = 0; + d = ret; + s = "_percent"; + for (; *s && n < usable; n++) + *d++ = *s++; + } else if (n > 3 && sorig[n - 3] == '/' && sorig[n - 2] == 's') { + n = n - 2; + d -= 2; + s = "_persec"; + for (; *s && n < usable; n++) + *d++ = *s++; + } + + *d = '\0'; + + return ret; +} + +/** + * Format host labels for the Prometheus exporter + * + * @param instance an instance data structure. + * @param host a data collecting host. + */ + +struct format_prometheus_label_callback { + struct instance *instance; + size_t count; +}; + +static int format_prometheus_label_callback(const char *name, const char *value, RRDLABEL_SRC ls __maybe_unused, void *data) { + struct format_prometheus_label_callback *d = (struct format_prometheus_label_callback *)data; + + if (!should_send_label(d->instance, ls)) return 0; + + char k[PROMETHEUS_ELEMENT_MAX + 1]; + char v[PROMETHEUS_ELEMENT_MAX + 1]; + + prometheus_name_copy(k, name, PROMETHEUS_ELEMENT_MAX); + prometheus_label_copy(v, value, PROMETHEUS_ELEMENT_MAX); + + if (*k && *v) { + if (d->count > 0) buffer_strcat(d->instance->labels_buffer, ","); + buffer_sprintf(d->instance->labels_buffer, "%s=\"%s\"", k, v); + d->count++; + } + return 1; +} + +void format_host_labels_prometheus(struct instance *instance, RRDHOST *host) +{ + if (unlikely(!sending_labels_configured(instance))) + return; + + if (!instance->labels_buffer) + instance->labels_buffer = buffer_create(1024, &netdata_buffers_statistics.buffers_exporters); + + struct format_prometheus_label_callback tmp = { + .instance = instance, + .count = 0 + }; + rrdlabels_walkthrough_read(host->rrdlabels, format_prometheus_label_callback, &tmp); +} + +/** + * Format host labels for the Prometheus exporter + * We are using a structure instead a direct buffer to expand options quickly. + * + * @param data is the buffer used to add labels. + */ + +static int format_prometheus_chart_label_callback(const char *name, const char *value, RRDLABEL_SRC ls __maybe_unused, void *data) { + BUFFER *wb = data; + + if (name[0] == '_' ) + return 1; + + char k[PROMETHEUS_ELEMENT_MAX + 1]; + char v[PROMETHEUS_ELEMENT_MAX + 1]; + + prometheus_name_copy(k, name, PROMETHEUS_ELEMENT_MAX); + prometheus_label_copy(v, value, PROMETHEUS_ELEMENT_MAX); + + if (*k && *v) + buffer_sprintf(wb, ",%s=\"%s\"", k, v); + + return 1; +} + +struct host_variables_callback_options { + RRDHOST *host; + BUFFER *wb; + BUFFER *plabels_buffer; + EXPORTING_OPTIONS exporting_options; + PROMETHEUS_OUTPUT_OPTIONS output_options; + const char *prefix; + const char *labels; + time_t now; + int host_header_printed; + char name[PROMETHEUS_VARIABLE_MAX + 1]; + SIMPLE_PATTERN *pattern; + struct instance *instance; + STRING *prometheus; +}; + +/** + * Print host variables. + * + * @param rv a variable. + * @param data callback options. + * @return Returns 1 if the chart can be sent, 0 otherwise. + */ +static int print_host_variables_callback(const DICTIONARY_ITEM *item __maybe_unused, void *rv_ptr __maybe_unused, void *data) { + const RRDVAR_ACQUIRED *rv = (const RRDVAR_ACQUIRED *)item; + + struct host_variables_callback_options *opts = data; + + if (!opts->host_header_printed) { + opts->host_header_printed = 1; + } + + NETDATA_DOUBLE value = rrdvar2number(rv); + if (isnan(value) || isinf(value)) { + return 0; + } + + char *label_pre = ""; + char *label_post = ""; + if (opts->labels && *opts->labels) { + label_pre = "{"; + label_post = "}"; + } + + prometheus_name_copy(opts->name, rrdvar_name(rv), sizeof(opts->name)); + + if (opts->output_options & PROMETHEUS_OUTPUT_TIMESTAMPS) + buffer_sprintf( + opts->wb, + "%s_%s%s%s%s " NETDATA_DOUBLE_FORMAT " %llu\n", + opts->prefix, + opts->name, + label_pre, + (opts->labels[0] == ',') ? &opts->labels[1] : opts->labels, + label_post, + value, + opts->now * 1000ULL); + else + buffer_sprintf( + opts->wb, + "%s_%s%s%s%s " NETDATA_DOUBLE_FORMAT "\n", + opts->prefix, + opts->name, + label_pre, + (opts->labels[0] == ',') ? &opts->labels[1] : opts->labels, + label_post, + value); + + return 1; +} + +struct gen_parameters { + const char *prefix; + const char *labels_prefix; + char *context; + char *suffix; + + char *chart; + char *dimension; + char *family; + char *labels; + + PROMETHEUS_OUTPUT_OPTIONS output_options; + RRDSET *st; + RRDDIM *rd; + + const char *relation; + const char *type; +}; + +/** + * Write an as-collected help comment to a buffer. + * + * @param wb the buffer to write the comment to. + * @param context context name we are using + */ +static inline void generate_as_collected_prom_help(BUFFER *wb, + const char *prefix, + char *context, + char *units, + char *suffix, + RRDSET *st) +{ + buffer_sprintf(wb, "# HELP %s_%s%s%s %s\n", prefix, context, units, suffix, rrdset_title(st)); +} + +/** + * Write an as-collected help comment to a buffer. + * + * @param wb the buffer to write the comment to. + * @param context context name we are using + */ +static inline void generate_as_collected_prom_type(BUFFER *wb, + const char *prefix, + char *context, + char *units, + char *suffix, + const char *type) +{ + buffer_sprintf(wb, "# TYPE %s_%s%s%s %s\n", prefix, context, units, suffix, type); +} + +/** + * Write an as-collected metric to a buffer. + * + * @param wb the buffer to write the metric to. + * @param p parameters for generating the metric string. + * @param homogeneous a flag for homogeneous charts. + * @param prometheus_collector a flag for metrics from prometheus collector. + * @param chart_labels the dictionary with chart labels + */ +static void generate_as_collected_from_metric(BUFFER *wb, + struct gen_parameters *p, + int homogeneous, + int prometheus_collector, + RRDLABELS *chart_labels) +{ + buffer_sprintf(wb, "%s_%s", p->prefix, p->context); + + if (!homogeneous) + buffer_sprintf(wb, "_%s", p->dimension); + + buffer_sprintf(wb, "%s{%schart=\"%s\"", p->suffix, p->labels_prefix, p->chart); + + if (homogeneous) + buffer_sprintf(wb, ",%sdimension=\"%s\"", p->labels_prefix, p->dimension); + + buffer_sprintf(wb, ",%sfamily=\"%s\"", p->labels_prefix, p->family); + + rrdlabels_walkthrough_read(chart_labels, format_prometheus_chart_label_callback, wb); + + buffer_sprintf(wb, "%s} ", p->labels); + + if (prometheus_collector) + buffer_sprintf( + wb, + NETDATA_DOUBLE_FORMAT, + (NETDATA_DOUBLE)p->rd->collector.last_collected_value * (NETDATA_DOUBLE)p->rd->multiplier / + (NETDATA_DOUBLE)p->rd->divisor); + else + buffer_sprintf(wb, COLLECTED_NUMBER_FORMAT, p->rd->collector.last_collected_value); + + if (p->output_options & PROMETHEUS_OUTPUT_TIMESTAMPS) + buffer_sprintf(wb, " %"PRIu64"\n", timeval_msec(&p->rd->collector.last_collected_time)); + else + buffer_sprintf(wb, "\n"); +} + +static void prometheus_print_os_info( + BUFFER *wb, + RRDHOST *host, + PROMETHEUS_OUTPUT_OPTIONS output_options) +{ + FILE *fp; + char filename[FILENAME_MAX + 1]; + char buf[BUFSIZ + 1]; + + snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/etc/os-release"); + fp = fopen(filename, "r"); + if (!fp) { + /* Fallback to lsb-release */ + snprintfz(filename, FILENAME_MAX, "%s%s", netdata_configured_host_prefix, "/etc/lsb-release"); + fp = fopen(filename, "r"); + } + if (!fp) { + return; + } + + buffer_sprintf(wb, "netdata_os_info{instance=\"%s\"", rrdhost_hostname(host)); + + while (fgets(buf, BUFSIZ, fp)) { + char *in, *sanitized; + char *key, *val; + int in_val_part = 0; + + /* sanitize the line */ + sanitized = in = buf; + in_val_part = 0; + while (*in && *in != '\n') { + if (!in_val_part) { + /* Only accepts alphabetic characters and '_' + * in key part */ + if (isalpha((uint8_t)*in) || *in == '_') { + *(sanitized++) = tolower((uint8_t)*in); + } else if (*in == '=') { + in_val_part = 1; + *(sanitized++) = '='; + } + } else { + /* Don't accept special characters in + * value part */ + switch (*in) { + case '"': + case '\'': + case '\r': + case '\t': + break; + default: + if (isprint((uint8_t)*in)) { + *(sanitized++) = *in; + } + } + } + in++; + } + /* Terminate the string */ + *(sanitized++) = '\0'; + + /* Split key/val */ + key = buf; + val = strchr(buf, '='); + + /* If we have a key/value pair, add it as a label */ + if (val) { + *val = '\0'; + val++; + buffer_sprintf(wb, ",%s=\"%s\"", key, val); + } + } + + /* Finish the line */ + if (output_options & PROMETHEUS_OUTPUT_TIMESTAMPS) + buffer_sprintf(wb, "} 1 %llu\n", now_realtime_usec() / USEC_PER_MS); + else + buffer_sprintf(wb, "} 1\n"); + + fclose(fp); +} + +/** + * RRDSET to JSON + * + * From RRDSET extract content necessary to write JSON output. + * + * @param st netdata chart structure + * @param data structure with necessary data and to build expected result. + * + * @return I returns 1 when content was used and 0 otherwise. + */ +static int prometheus_rrdset_to_json(RRDSET *st, void *data) +{ + struct host_variables_callback_options *opts = data; + + if (likely(can_send_rrdset(opts->instance, st, opts->pattern))) { + PROMETHEUS_OUTPUT_OPTIONS output_options = opts->output_options; + BUFFER *wb = opts->wb; + const char *prefix = opts->prefix; + + BUFFER *plabels_buffer = opts->plabels_buffer; + const char *plabels_prefix = opts->instance->config.label_prefix; + + STRING *prometheus = opts->prometheus; + + char chart[PROMETHEUS_ELEMENT_MAX + 1]; + char context[PROMETHEUS_ELEMENT_MAX + 1]; + char family[PROMETHEUS_ELEMENT_MAX + 1]; + char units[PROMETHEUS_ELEMENT_MAX + 1] = ""; + + prometheus_label_copy(chart, + (output_options & PROMETHEUS_OUTPUT_NAMES && st->name) ? + rrdset_name(st) : rrdset_id(st), PROMETHEUS_ELEMENT_MAX); + prometheus_label_copy(family, rrdset_family(st), PROMETHEUS_ELEMENT_MAX); + prometheus_name_copy(context, rrdset_context(st), PROMETHEUS_ELEMENT_MAX); + + int as_collected = (EXPORTING_OPTIONS_DATA_SOURCE(opts->exporting_options) + == EXPORTING_SOURCE_DATA_AS_COLLECTED); + int homogeneous = 1; + int prometheus_collector = 0; + RRDSET_FLAGS flags = rrdset_flag_get(st); + if (as_collected) { + if (flags & RRDSET_FLAG_HOMOGENEOUS_CHECK) + rrdset_update_heterogeneous_flag(st); + + if (flags & RRDSET_FLAG_HETEROGENEOUS) + homogeneous = 0; + + if (st->module_name == prometheus) + prometheus_collector = 1; + } + else { + if (EXPORTING_OPTIONS_DATA_SOURCE(opts->exporting_options) == EXPORTING_SOURCE_DATA_AVERAGE && + !(output_options & PROMETHEUS_OUTPUT_HIDEUNITS)) + prometheus_units_copy(units, + rrdset_units(st), + PROMETHEUS_ELEMENT_MAX, + output_options & PROMETHEUS_OUTPUT_OLDUNITS); + } + + // for each dimension + RRDDIM *rd; + rrddim_foreach_read(rd, st) { + + if (rd->collector.counter && !rrddim_flag_check(rd, RRDDIM_FLAG_OBSOLETE)) { + char dimension[PROMETHEUS_ELEMENT_MAX + 1]; + char *suffix = ""; + + struct gen_parameters p; + p.prefix = prefix; + p.labels_prefix = plabels_prefix; + p.context = context; + p.suffix = suffix; + p.chart = chart; + p.dimension = dimension; + p.family = family; + p.labels = (char *)opts->labels; + p.output_options = output_options; + p.st = st; + p.rd = rd; + + if (as_collected) { + // we need as-collected / raw data + + if (unlikely(rd->collector.last_collected_time.tv_sec < opts->instance->after)) + continue; + + p.type = "gauge"; + p.relation = "gives"; + if (rd->algorithm == RRD_ALGORITHM_INCREMENTAL || + rd->algorithm == RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL) { + p.type = "counter"; + p.relation = "delta gives"; + if (!prometheus_collector) + p.suffix = "_total"; + } + + if (opts->output_options & PROMETHEUS_OUTPUT_HELP_TYPE) { + generate_as_collected_prom_help(wb, prefix, context, units, suffix, st); + generate_as_collected_prom_type(wb, prefix, context, units, p.suffix, p.type); + opts->output_options &= ~PROMETHEUS_OUTPUT_HELP_TYPE; + } + + if (homogeneous) { + // all the dimensions of the chart, has the same algorithm, multiplier and divisor + // we add all dimensions as labels + + prometheus_label_copy( + dimension, + (output_options & PROMETHEUS_OUTPUT_NAMES && rd->name) ? rrddim_name(rd) : rrddim_id(rd), + PROMETHEUS_ELEMENT_MAX); + } + else { + // the dimensions of the chart, do not have the same algorithm, multiplier or divisor + // we create a metric per dimension + + prometheus_name_copy( + dimension, + (output_options & PROMETHEUS_OUTPUT_NAMES && rd->name) ? rrddim_name(rd) : rrddim_id(rd), + PROMETHEUS_ELEMENT_MAX); + } + generate_as_collected_from_metric(wb, &p, homogeneous, prometheus_collector, st->rrdlabels); + } + else { + // we need average or sum of the data + + time_t last_time = opts->instance->before; + NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(opts->instance, rd, &last_time); + + if (!isnan(value) && !isinf(value)) { + if (EXPORTING_OPTIONS_DATA_SOURCE(opts->exporting_options) + == EXPORTING_SOURCE_DATA_AVERAGE) + suffix = "_average"; + else if (EXPORTING_OPTIONS_DATA_SOURCE(opts->exporting_options) + == EXPORTING_SOURCE_DATA_SUM) + suffix = "_sum"; + + prometheus_label_copy( + dimension, + (output_options & PROMETHEUS_OUTPUT_NAMES && rd->name) ? rrddim_name(rd) : rrddim_id(rd), + PROMETHEUS_ELEMENT_MAX); + + if (opts->output_options & PROMETHEUS_OUTPUT_HELP_TYPE) { + generate_as_collected_prom_help(wb, prefix, context, units, suffix, st); + generate_as_collected_prom_type(wb, prefix, context, units, p.suffix, "gauge"); + opts->output_options &= ~PROMETHEUS_OUTPUT_HELP_TYPE; + } + + buffer_flush(plabels_buffer); + buffer_sprintf(plabels_buffer, + "%1$schart=\"%2$s\",%1$sdimension=\"%3$s\",%1$sfamily=\"%4$s\"", + plabels_prefix, + chart, + dimension, + family); + rrdlabels_walkthrough_read(st->rrdlabels, + format_prometheus_chart_label_callback, + plabels_buffer); + + if (output_options & PROMETHEUS_OUTPUT_TIMESTAMPS) + buffer_sprintf(wb, + "%s_%s%s%s{%s%s} " NETDATA_DOUBLE_FORMAT " %llu\n", + prefix, + context, + units, + suffix, + buffer_tostring(plabels_buffer), + opts->labels, + value, + last_time * MSEC_PER_SEC); + else + buffer_sprintf(wb, "%s_%s%s%s{%s%s} " NETDATA_DOUBLE_FORMAT "\n", + prefix, + context, + units, + suffix, + buffer_tostring(plabels_buffer), + opts->labels, + value); + } + } + } + } + rrddim_foreach_done(rd); + + return 1; + } + + return 0; +} + +/** + * RRDCONTEXT callback + * + * Callback used to parse dictionary + * + * @param item the dictionary structure + * @param value unused element + * @param data structure used to store data. + * + * @return It always returns HTTP_RESP_OK + */ +static inline int prometheus_rrdcontext_callback(const DICTIONARY_ITEM *item, void *value, void *data) +{ + const char *context_name = dictionary_acquired_item_name(item); + struct host_variables_callback_options *opts = data; + (void)value; + + opts->output_options |= PROMETHEUS_OUTPUT_HELP_TYPE; + (void)rrdcontext_foreach_instance_with_rrdset_in_context(opts->host, context_name, prometheus_rrdset_to_json, data); + + return HTTP_RESP_OK; +} + +/** + * Write metrics in Prometheus format to a buffer. + * + * @param instance an instance data structure. + * @param host a data collecting host. + * @param filter_string a simple pattern filter. + * @param wb the buffer to fill with metrics. + * @param prefix a prefix for every metric. + * @param exporting_options options to configure what data is exported. + * @param allhosts set to 1 if host instance should be in the output for tags. + * @param output_options options to configure the format of the output. + */ +static void rrd_stats_api_v1_charts_allmetrics_prometheus( + struct instance *instance, + RRDHOST *host, + const char *filter_string, + BUFFER *wb, + const char *prefix, + EXPORTING_OPTIONS exporting_options, + int allhosts, + PROMETHEUS_OUTPUT_OPTIONS output_options) +{ + SIMPLE_PATTERN *filter = simple_pattern_create(filter_string, NULL, SIMPLE_PATTERN_EXACT, true); + + char hostname[PROMETHEUS_ELEMENT_MAX + 1]; + prometheus_label_copy(hostname, rrdhost_hostname(host), PROMETHEUS_ELEMENT_MAX); + + format_host_labels_prometheus(instance, host); + + buffer_sprintf( + wb, + "netdata_info{instance=\"%s\",application=\"%s\",version=\"%s\"", + hostname, + rrdhost_program_name(host), + rrdhost_program_version(host)); + + if (instance->labels_buffer && *buffer_tostring(instance->labels_buffer)) { + buffer_sprintf(wb, ",%s", buffer_tostring(instance->labels_buffer)); + } + + if (output_options & PROMETHEUS_OUTPUT_TIMESTAMPS) + buffer_sprintf(wb, "} 1 %llu\n", now_realtime_usec() / USEC_PER_MS); + else + buffer_sprintf(wb, "} 1\n"); + + char labels[PROMETHEUS_LABELS_MAX + 1] = ""; + if (allhosts) { + snprintfz(labels, PROMETHEUS_LABELS_MAX, ",%sinstance=\"%s\"", instance->config.label_prefix, hostname); + } + + if (instance->labels_buffer) + buffer_flush(instance->labels_buffer); + + if (instance->config.options & EXPORTING_OPTION_SEND_AUTOMATIC_LABELS) + prometheus_print_os_info(wb, host, output_options); + + + BUFFER *plabels_buffer = buffer_create(0, NULL); + + struct host_variables_callback_options opts = { + .host = host, + .wb = wb, + .plabels_buffer = plabels_buffer, + .labels = labels, // FIX: very misleading name and poor implementation of adding the "instance" label + .exporting_options = exporting_options, + .output_options = output_options, + .prefix = prefix, + .now = now_realtime_sec(), + .host_header_printed = 0, + .pattern = filter, + .instance = instance, + .prometheus = string_strdupz("prometheus") + }; + + // send custom variables set for the host + if (output_options & PROMETHEUS_OUTPUT_VARIABLES) { + rrdvar_walkthrough_read(host->rrdvars, print_host_variables_callback, &opts); + } + + // for each context + if (!host->rrdctx.contexts) { + netdata_log_error("%s(): request for host '%s' that does not have rrdcontexts initialized.", __FUNCTION__, rrdhost_hostname(host)); + goto allmetrics_cleanup; + } + + dictionary_walkthrough_read(host->rrdctx.contexts, prometheus_rrdcontext_callback, &opts); + +allmetrics_cleanup: + simple_pattern_free(filter); + buffer_free(plabels_buffer); + string_freez(opts.prometheus); +} + +/** + * Get the last time time when a server accessed Netdata. Write information about an API request to a buffer. + * + * @param instance an instance data structure. + * @param host a data collecting host. + * @param wb the buffer to write to. + * @param exporting_options options to configure what data is exported. + * @param server the name of a Prometheus server.. + * @param now actual time. + * @param output_options options to configure the format of the output. + * @return Returns the last time when the server accessed Netdata. + */ +static inline time_t prometheus_preparation( + struct instance *instance, + RRDHOST *host, + const char *server, + time_t now) +{ +#ifndef UNIT_TESTING + analytics_log_prometheus(); +#endif + if (!server || !*server) + server = "default"; + + time_t after = prometheus_server_last_access(server, host, now); + + if (!after) { + after = now - instance->config.update_every; + } + + if (after > now) { + // oops! this should never happen + after = now - instance->config.update_every; + } + + return after; +} + +/** + * Write metrics and auxiliary information for one host to a buffer. + * + * @param host a data collecting host. + * @param filter_string a simple pattern filter. + * @param wb the buffer to write to. + * @param server the name of a Prometheus server. + * @param prefix a prefix for every metric. + * @param exporting_options options to configure what data is exported. + * @param output_options options to configure the format of the output. + */ +void rrd_stats_api_v1_charts_allmetrics_prometheus_single_host( + RRDHOST *host, + const char *filter_string, + BUFFER *wb, + const char *server, + const char *prefix, + EXPORTING_OPTIONS exporting_options, + PROMETHEUS_OUTPUT_OPTIONS output_options) +{ + if (unlikely(!prometheus_exporter_instance || !prometheus_exporter_instance->config.initialized)) + return; + + prometheus_exporter_instance->before = now_realtime_sec(); + + // we start at the point we had stopped before + prometheus_exporter_instance->after = prometheus_preparation( + prometheus_exporter_instance, + host, + server, + prometheus_exporter_instance->before); + + rrd_stats_api_v1_charts_allmetrics_prometheus( + prometheus_exporter_instance, host, filter_string, wb, prefix, exporting_options, 0, output_options); +} + +/** + * Write metrics and auxiliary information for all hosts to a buffer. + * + * @param host a data collecting host. + * @param filter_string a simple pattern filter. + * @param wb the buffer to write to. + * @param server the name of a Prometheus server. + * @param prefix a prefix for every metric. + * @param exporting_options options to configure what data is exported. + * @param output_options options to configure the format of the output. + */ +void rrd_stats_api_v1_charts_allmetrics_prometheus_all_hosts( + RRDHOST *host, + const char *filter_string, + BUFFER *wb, + const char *server, + const char *prefix, + EXPORTING_OPTIONS exporting_options, + PROMETHEUS_OUTPUT_OPTIONS output_options) +{ + if (unlikely(!prometheus_exporter_instance || !prometheus_exporter_instance->config.initialized)) + return; + + prometheus_exporter_instance->before = now_realtime_sec(); + + // we start at the point we had stopped before + prometheus_exporter_instance->after = prometheus_preparation( + prometheus_exporter_instance, + host, + server, + prometheus_exporter_instance->before); + + dfe_start_reentrant(rrdhost_root_index, host) + { + rrd_stats_api_v1_charts_allmetrics_prometheus( + prometheus_exporter_instance, host, filter_string, wb, prefix, exporting_options, 1, output_options); + } + dfe_done(host); +} |