src/write_prometheus.c

   1 /**
   2  * collectd - src/write_prometheus.c
   3  * Copyright (C) 2016       Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at collectd.org>
  25  */
  26
  27 #include "collectd.h"
  28
  29 #include "common.h"
  30 #include "plugin.h"
  31 #include "utils_avltree.h"
  32 #include "utils_complain.h"
  33 #include "utils_time.h"
  34
  35 #include "prometheus.pb-c.h"
  36
  37 #include <microhttpd.h>
  38
  39 #ifndef PROMETHEUS_DEFAULT_STALENESS_DELTA
  40 #define PROMETHEUS_DEFAULT_STALENESS_DELTA TIME_T_TO_CDTIME_T(300)
  41 #endif
  42
  43 #define VARINT_UINT32_BYTES 5
  44
  45 #define CONTENT_TYPE_PROTO                                                     \
  46   "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; " \
  47   "encoding=delimited"
  48 #define CONTENT_TYPE_TEXT "text/plain; version=0.0.4"
  49
  50 static c_avl_tree_t *metrics;
  51 static pthread_mutex_t metrics_lock = PTHREAD_MUTEX_INITIALIZER;
  52
  53 static unsigned short httpd_port = 9103;
  54 static struct MHD_Daemon *httpd;
  55
  56 static cdtime_t staleness_delta = PROMETHEUS_DEFAULT_STALENESS_DELTA;
  57
  58 /* Unfortunately, protoc-c doesn't export it's implementation of varint, so we
  59  * need to implement our own. */
  60 static size_t varint(uint8_t buffer[static VARINT_UINT32_BYTES],
  61                      uint32_t value) {
  62   for (size_t i = 0; i < VARINT_UINT32_BYTES; i++) {
  63     buffer[i] = (uint8_t)(value & 0x7f);
  64     value >>= 7;
  65
  66     if (value == 0)
  67       return i + 1;
  68
  69     buffer[i] |= 0x80;
  70   }
  71
  72   return 0;
  73 }
  74
  75 /* format_protobuf iterates over all metric families in "metrics" and adds them
  76  * to a buffer in ProtoBuf format. It prefixes each protobuf with its encoded
  77  * size, the so called "delimited" format. */
  78 static void format_protobuf(ProtobufCBuffer *buffer) {
  79   pthread_mutex_lock(&metrics_lock);
  80
  81   char *unused_name;
  82   Io__Prometheus__Client__MetricFamily *fam;
  83   c_avl_iterator_t *iter = c_avl_get_iterator(metrics);
  84   while (c_avl_iterator_next(iter, (void *)&unused_name, (void *)&fam) == 0) {
  85     /* Prometheus uses a message length prefix to determine where one
  86      * MetricFamily ends and the next begins. This delimiter is encoded as a
  87      * "varint", which is common in Protobufs. */
  88     uint8_t delim[VARINT_UINT32_BYTES] = {0};
  89     size_t delim_len = varint(
  90         delim,
  91         (uint32_t)io__prometheus__client__metric_family__get_packed_size(fam));
  92     buffer->append(buffer, delim_len, delim);
  93
  94     io__prometheus__client__metric_family__pack_to_buffer(fam, buffer);
  95   }
  96   c_avl_iterator_destroy(iter);
  97
  98   pthread_mutex_unlock(&metrics_lock);
  99 }
 100
 101 /* format_labels formats a metric's labels in Prometheus-compatible format. This
 102  * format looks like this:
 103  *
 104  *   key0="value0",key1="value1"
 105  */
 106 static char *format_labels(char *buffer, size_t buffer_size,
 107                            Io__Prometheus__Client__Metric const *m) {
 108   /* our metrics always have at least one and at most three labels. */
 109   assert(m->n_label >= 1);
 110   assert(m->n_label <= 3);
 111
 112 #define LABEL_BUFFER_SIZE (2 * DATA_MAX_NAME_LEN + 4)
 113
 114   char *labels[3] = {
 115       (char[LABEL_BUFFER_SIZE]){0}, (char[LABEL_BUFFER_SIZE]){0},
 116       (char[LABEL_BUFFER_SIZE]){0},
 117   };
 118
 119   for (size_t i = 0; i < m->n_label; i++)
 120     ssnprintf(labels[i], LABEL_BUFFER_SIZE, "%s=\"%s\"", m->label[i]->name,
 121               m->label[i]->value);
 122
 123   strjoin(buffer, buffer_size, labels, m->n_label, ",");
 124   return buffer;
 125 }
 126
 127 /* format_protobuf iterates over all metric families in "metrics" and adds them
 128  * to a buffer in plain text format. */
 129 static void format_text(ProtobufCBuffer *buffer) {
 130   pthread_mutex_lock(&metrics_lock);
 131
 132   char *unused_name;
 133   Io__Prometheus__Client__MetricFamily *fam;
 134   c_avl_iterator_t *iter = c_avl_get_iterator(metrics);
 135   while (c_avl_iterator_next(iter, (void *)&unused_name, (void *)&fam) == 0) {
 136     char line[1024]; /* 4x DATA_MAX_NAME_LEN? */
 137
 138     ssnprintf(line, sizeof(line), "# HELP %s %s\n", fam->name, fam->help);
 139     buffer->append(buffer, strlen(line), (uint8_t *)line);
 140
 141     ssnprintf(line, sizeof(line), "# TYPE %s %s\n", fam->name,
 142               (fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__GAUGE)
 143                   ? "gauge"
 144                   : "counter");
 145     buffer->append(buffer, strlen(line), (uint8_t *)line);
 146
 147     for (size_t i = 0; i < fam->n_metric; i++) {
 148       Io__Prometheus__Client__Metric *m = fam->metric[i];
 149
 150       char labels[1024];
 151
 152       char timestamp_ms[24] = "";
 153       if (m->has_timestamp_ms)
 154         ssnprintf(timestamp_ms, sizeof(timestamp_ms), " %" PRIi64,
 155                   m->timestamp_ms);
 156
 157       if (fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__GAUGE)
 158         ssnprintf(line, sizeof(line), "%s{%s} " GAUGE_FORMAT "%s\n", fam->name,
 159                   format_labels(labels, sizeof(labels), m), m->gauge->value,
 160                   timestamp_ms);
 161       else /* if (fam->type == IO__PROMETHEUS__CLIENT__METRIC_TYPE__COUNTER) */
 162         ssnprintf(line, sizeof(line), "%s{%s} %.0f%s\n", fam->name,
 163                   format_labels(labels, sizeof(labels), m), m->counter->value,
 164                   timestamp_ms);
 165
 166       buffer->append(buffer, strlen(line), (uint8_t *)line);
 167     }
 168   }
 169   c_avl_iterator_destroy(iter);
 170
 171   char server[1024];
 172   ssnprintf(server, sizeof(server), "\n# collectd/write_prometheus %s at %s\n",
 173             PACKAGE_VERSION, hostname_g);
 174   buffer->append(buffer, strlen(server), (uint8_t *)server);
 175
 176   pthread_mutex_unlock(&metrics_lock);
 177 }
 178
 179 /* http_handler is the callback called by the microhttpd library. It essentially
 180  * handles all HTTP request aspects and creates an HTTP response. */
 181 static int http_handler(void *cls, struct MHD_Connection *connection,
 182                         const char *url, const char *method,
 183                         const char *version, const char *upload_data,
 184                         size_t *upload_data_size, void **connection_state) {
 185   if (strcmp(method, MHD_HTTP_METHOD_GET) != 0) {
 186     return MHD_NO;
 187   }
 188
 189   /* On the first call for each connection, return without anything further.
 190    * Apparently not everything has been initialized yet or so; the docs are not
 191    * very specific on the issue. */
 192   if (*connection_state == NULL) {
 193     /* set to a random non-NULL pointer. */
 194     *connection_state = &(int){42};
 195     return MHD_YES;
 196   }
 197
 198   char const *accept = MHD_lookup_connection_value(connection, MHD_HEADER_KIND,
 199                                                    MHD_HTTP_HEADER_ACCEPT);
 200   _Bool want_proto =
 201       (accept != NULL) &&
 202       (strstr(accept, "application/vnd.google.protobuf") != NULL);
 203
 204   uint8_t scratch[4096] = {0};
 205   ProtobufCBufferSimple simple = PROTOBUF_C_BUFFER_SIMPLE_INIT(scratch);
 206   ProtobufCBuffer *buffer = (ProtobufCBuffer *)&simple;
 207
 208   if (want_proto)
 209     format_protobuf(buffer);
 210   else
 211     format_text(buffer);
 212
 213   struct MHD_Response *res = MHD_create_response_from_data(
 214       simple.len, simple.data, /* must_free = */ 0, /* must_copy = */ 1);
 215   MHD_add_response_header(res, MHD_HTTP_HEADER_CONTENT_TYPE,
 216                           want_proto ? CONTENT_TYPE_PROTO : CONTENT_TYPE_TEXT);
 217
 218   int status = MHD_queue_response(connection, MHD_HTTP_OK, res);
 219
 220   MHD_destroy_response(res);
 221   PROTOBUF_C_BUFFER_SIMPLE_CLEAR(&simple);
 222   return status;
 223 }
 224
 225 /*
 226  * Functions for manipulating the global state in "metrics". This is organized
 227  * in two tiers: the global "metrics" tree holds "metric families", which are
 228  * identified by a name (a string). Each metric family has one or more
 229  * "metrics", which are identified by a unique set of key-value-pairs. For
 230  * example:
 231  *
 232  * collectd_cpu_total
 233  *   {cpu="0",type="idle"}
 234  *   {cpu="0",type="user"}
 235  *   ...
 236  * collectd_memory
 237  *   {memory="used"}
 238  *   {memory="free"}
 239  *   ...
 240  * {{{ */
 241 /* label_pair_destroy frees the memory used by a label pair. */
 242 static void label_pair_destroy(Io__Prometheus__Client__LabelPair *msg) {
 243   if (msg == NULL)
 244     return;
 245
 246   sfree(msg->name);
 247   sfree(msg->value);
 248
 249   sfree(msg);
 250 }
 251
 252 /* label_pair_clone allocates and initializes a new label pair. */
 253 static Io__Prometheus__Client__LabelPair *
 254 label_pair_clone(Io__Prometheus__Client__LabelPair const *orig) {
 255   Io__Prometheus__Client__LabelPair *copy = calloc(1, sizeof(*copy));
 256   if (copy == NULL)
 257     return NULL;
 258   io__prometheus__client__label_pair__init(copy);
 259
 260   copy->name = strdup(orig->name);
 261   copy->value = strdup(orig->value);
 262   if ((copy->name == NULL) || (copy->value == NULL)) {
 263     label_pair_destroy(copy);
 264     return NULL;
 265   }
 266
 267   return copy;
 268 }
 269
 270 /* metric_destroy frees the memory used by a metric. */
 271 static void metric_destroy(Io__Prometheus__Client__Metric *msg) {
 272   if (msg == NULL)
 273     return;
 274
 275   for (size_t i = 0; i < msg->n_label; i++) {
 276     label_pair_destroy(msg->label[i]);
 277   }
 278   sfree(msg->label);
 279
 280   sfree(msg->gauge);
 281   sfree(msg->counter);
 282
 283   sfree(msg);
 284 }
 285
 286 /* metric_cmp compares two metrics. It's prototype makes it easy to use with
 287  * qsort(3) and bsearch(3). */
 288 static int metric_cmp(void const *a, void const *b) {
 289   Io__Prometheus__Client__Metric const *m_a =
 290       *((Io__Prometheus__Client__Metric **)a);
 291   Io__Prometheus__Client__Metric const *m_b =
 292       *((Io__Prometheus__Client__Metric **)b);
 293
 294   if (m_a->n_label < m_b->n_label)
 295     return -1;
 296   else if (m_a->n_label > m_b->n_label)
 297     return 1;
 298
 299   /* Prometheus does not care about the order of labels. All labels in this
 300    * plugin are created by metric_add_labels(), though, and therefore always
 301    * appear in the same order. We take advantage of this and simplify the check
 302    * by making sure all labels are the same in each position. */
 303   for (size_t i = 0; i < m_a->n_label; i++) {
 304     int status = strcmp(m_a->label[i]->name, m_b->label[i]->name);
 305     if (status != 0)
 306       return status;
 307
 308     status = strcmp(m_a->label[i]->value, m_b->label[i]->value);
 309     if (status != 0)
 310       return status;
 311   }
 312
 313   return 0;
 314 }
 315
 316 #define METRIC_INIT                                                            \
 317   &(Io__Prometheus__Client__Metric) {                                          \
 318     .label =                                                                   \
 319         (Io__Prometheus__Client__LabelPair *[]){                               \
 320             &(Io__Prometheus__Client__LabelPair){                              \
 321                 .name = NULL,                                                  \
 322             },                                                                 \
 323             &(Io__Prometheus__Client__LabelPair){                              \
 324                 .name = NULL,                                                  \
 325             },                                                                 \
 326             &(Io__Prometheus__Client__LabelPair){                              \
 327                 .name = NULL,                                                  \
 328             },                                                                 \
 329         },                                                                     \
 330     .n_label = 0,                                                              \
 331   }
 332
 333 #define METRIC_ADD_LABELS(m, vl)                                               \
 334   do {                                                                         \
 335     if (strlen((vl)->plugin_instance) != 0) {                                  \
 336       (m)->label[(m)->n_label]->name = (char *)(vl)->plugin;                   \
 337       (m)->label[(m)->n_label]->value = (char *)(vl)->plugin_instance;         \
 338       (m)->n_label++;                                                          \
 339     }                                                                          \
 340                                                                                \
 341     if (strlen((vl)->type_instance) != 0) {                                    \
 342       (m)->label[(m)->n_label]->name = "type";                                 \
 343       if (strlen((vl)->plugin_instance) == 0)                                  \
 344         (m)->label[(m)->n_label]->name = (char *)(vl)->plugin;                 \
 345       (m)->label[(m)->n_label]->value = (char *)(vl)->type_instance;           \
 346       (m)->n_label++;                                                          \
 347     }                                                                          \
 348                                                                                \
 349     (m)->label[(m)->n_label]->name = "instance";                               \
 350     (m)->label[(m)->n_label]->value = (char *)(vl)->host;                      \
 351     (m)->n_label++;                                                            \
 352   } while (0)
 353
 354 /* metric_clone allocates and initializes a new metric based on orig. */
 355 static Io__Prometheus__Client__Metric *
 356 metric_clone(Io__Prometheus__Client__Metric const *orig) {
 357   Io__Prometheus__Client__Metric *copy = calloc(1, sizeof(*copy));
 358   if (copy == NULL)
 359     return NULL;
 360   io__prometheus__client__metric__init(copy);
 361
 362   copy->n_label = orig->n_label;
 363   copy->label = calloc(copy->n_label, sizeof(*copy->label));
 364   if (copy->label == NULL) {
 365     sfree(copy);
 366     return NULL;
 367   }
 368
 369   for (size_t i = 0; i < copy->n_label; i++) {
 370     copy->label[i] = label_pair_clone(orig->label[i]);
 371     if (copy->label[i] == NULL) {
 372       metric_destroy(copy);
 373       return NULL;
 374     }
 375   }
 376
 377   return copy;
 378 }
 379
 380 /* metric_update stores the new value and timestamp in m. */
 381 static int metric_update(Io__Prometheus__Client__Metric *m, value_t value,
 382                          int ds_type, cdtime_t t, cdtime_t interval) {
 383   if (ds_type == DS_TYPE_GAUGE) {
 384     sfree(m->counter);
 385     if (m->gauge == NULL) {
 386       m->gauge = calloc(1, sizeof(*m->gauge));
 387       if (m->gauge == NULL)
 388         return ENOMEM;
 389       io__prometheus__client__gauge__init(m->gauge);
 390     }
 391
 392     m->gauge->value = (double)value.gauge;
 393     m->gauge->has_value = 1;
 394   } else { /* not gauge */
 395     sfree(m->gauge);
 396     if (m->counter == NULL) {
 397       m->counter = calloc(1, sizeof(*m->counter));
 398       if (m->counter == NULL)
 399         return ENOMEM;
 400       io__prometheus__client__counter__init(m->counter);
 401     }
 402
 403     switch (ds_type) {
 404     case DS_TYPE_ABSOLUTE:
 405       m->counter->value = (double)value.absolute;
 406       break;
 407     case DS_TYPE_COUNTER:
 408       m->counter->value = (double)value.counter;
 409       break;
 410     default:
 411       m->counter->value = (double)value.derive;
 412       break;
 413     }
 414     m->counter->has_value = 1;
 415   }
 416
 417   /* Prometheus has a globally configured timeout after which metrics are
 418    * considered stale. This causes problems when metrics have an interval
 419    * exceeding that limit. We emulate the behavior of "pushgateway" and *not*
 420    * send a timestamp value – Prometheus will fill in the current time. */
 421   if (interval <= staleness_delta) {
 422     m->timestamp_ms = CDTIME_T_TO_MS(t);
 423     m->has_timestamp_ms = 1;
 424   } else {
 425     static c_complain_t long_metric = C_COMPLAIN_INIT_STATIC;
 426     c_complain(
 427         LOG_NOTICE, &long_metric,
 428         "write_prometheus plugin: You have metrics with an interval exceeding "
 429         "\"StalenessDelta\" setting (%.3fs). This is suboptimal, please check "
 430         "the collectd.conf(5) manual page to understand what's going on.",
 431         CDTIME_T_TO_DOUBLE(staleness_delta));
 432
 433     m->timestamp_ms = 0;
 434     m->has_timestamp_ms = 0;
 435   }
 436
 437   return 0;
 438 }
 439
 440 /* metric_family_add_metric adds m to the metric list of fam. */
 441 static int metric_family_add_metric(Io__Prometheus__Client__MetricFamily *fam,
 442                                     Io__Prometheus__Client__Metric *m) {
 443   Io__Prometheus__Client__Metric **tmp =
 444       realloc(fam->metric, (fam->n_metric + 1) * sizeof(*fam->metric));
 445   if (tmp == NULL)
 446     return ENOMEM;
 447   fam->metric = tmp;
 448
 449   fam->metric[fam->n_metric] = m;
 450   fam->n_metric++;
 451
 452   /* Sort the metrics so that lookup is fast. */
 453   qsort(fam->metric, fam->n_metric, sizeof(*fam->metric), metric_cmp);
 454
 455   return 0;
 456 }
 457
 458 /* metric_family_delete_metric looks up and deletes the metric corresponding to
 459  * vl. */
 460 static int
 461 metric_family_delete_metric(Io__Prometheus__Client__MetricFamily *fam,
 462                             value_list_t const *vl) {
 463   Io__Prometheus__Client__Metric *key = METRIC_INIT;
 464   METRIC_ADD_LABELS(key, vl);
 465
 466   size_t i;
 467   for (i = 0; i < fam->n_metric; i++) {
 468     if (metric_cmp(&key, &fam->metric[i]) == 0)
 469       break;
 470   }
 471
 472   if (i >= fam->n_metric)
 473     return ENOENT;
 474
 475   metric_destroy(fam->metric[i]);
 476   if ((fam->n_metric - 1) > i)
 477     memmove(&fam->metric[i], &fam->metric[i + 1],
 478             ((fam->n_metric - 1) - i) * sizeof(fam->metric[i]));
 479   fam->n_metric--;
 480
 481   Io__Prometheus__Client__Metric **tmp =
 482       realloc(fam->metric, fam->n_metric * sizeof(*fam->metric));
 483   if ((tmp != NULL) || (fam->n_metric == 0))
 484     fam->metric = tmp;
 485
 486   return 0;
 487 }
 488
 489 /* metric_family_get_metric looks up the matching metric in a metric family,
 490  * allocating it if necessary. */
 491 static Io__Prometheus__Client__Metric *
 492 metric_family_get_metric(Io__Prometheus__Client__MetricFamily *fam,
 493                          value_list_t const *vl) {
 494   Io__Prometheus__Client__Metric *key = METRIC_INIT;
 495   METRIC_ADD_LABELS(key, vl);
 496
 497   /* Metrics are sorted in metric_family_add_metric() so that we can do a binary
 498    * search here. */
 499   Io__Prometheus__Client__Metric **m = bsearch(
 500       &key, fam->metric, fam->n_metric, sizeof(*fam->metric), metric_cmp);
 501
 502   if (m != NULL) {
 503     return *m;
 504   }
 505
 506   Io__Prometheus__Client__Metric *new_metric = metric_clone(key);
 507   if (new_metric == NULL)
 508     return NULL;
 509
 510   DEBUG("write_prometheus plugin: created new metric in family");
 511   int status = metric_family_add_metric(fam, new_metric);
 512   if (status != 0) {
 513     metric_destroy(new_metric);
 514     return NULL;
 515   }
 516
 517   return new_metric;
 518 }
 519
 520 /* metric_family_update looks up the matching metric in a metric family,
 521  * allocating it if necessary, and updates the metric to the latest value. */
 522 static int metric_family_update(Io__Prometheus__Client__MetricFamily *fam,
 523                                 data_set_t const *ds, value_list_t const *vl,
 524                                 size_t ds_index) {
 525   Io__Prometheus__Client__Metric *m = metric_family_get_metric(fam, vl);
 526   if (m == NULL)
 527     return -1;
 528
 529   return metric_update(m, vl->values[ds_index], ds->ds[ds_index].type, vl->time,
 530                        vl->interval);
 531 }
 532
 533 /* metric_family_destroy frees the memory used by a metric family. */
 534 static void metric_family_destroy(Io__Prometheus__Client__MetricFamily *msg) {
 535   if (msg == NULL)
 536     return;
 537
 538   sfree(msg->name);
 539   sfree(msg->help);
 540
 541   for (size_t i = 0; i < msg->n_metric; i++) {
 542     metric_destroy(msg->metric[i]);
 543   }
 544   sfree(msg->metric);
 545
 546   sfree(msg);
 547 }
 548
 549 /* metric_family_create allocates and initializes a new metric family. */
 550 static Io__Prometheus__Client__MetricFamily *
 551 metric_family_create(char *name, data_set_t const *ds, value_list_t const *vl,
 552                      size_t ds_index) {
 553   Io__Prometheus__Client__MetricFamily *msg = calloc(1, sizeof(*msg));
 554   if (msg == NULL)
 555     return NULL;
 556   io__prometheus__client__metric_family__init(msg);
 557
 558   msg->name = name;
 559
 560   char help[1024];
 561   ssnprintf(
 562       help, sizeof(help),
 563       "write_prometheus plugin: '%s' Type: '%s', Dstype: '%s', Dsname: '%s'",
 564       vl->plugin, vl->type, DS_TYPE_TO_STRING(ds->ds[ds_index].type),
 565       ds->ds[ds_index].name);
 566   msg->help = strdup(help);
 567
 568   msg->type = (ds->ds[ds_index].type == DS_TYPE_GAUGE)
 569                   ? IO__PROMETHEUS__CLIENT__METRIC_TYPE__GAUGE
 570                   : IO__PROMETHEUS__CLIENT__METRIC_TYPE__COUNTER;
 571   msg->has_type = 1;
 572
 573   return msg;
 574 }
 575
 576 /* metric_family_name creates a metric family's name from a data source. This is
 577  * done in the same way as done by the "collectd_exporter" for best possible
 578  * compatibility. In essence, the plugin, type and data source name go in the
 579  * metric family name, while hostname, plugin instance and type instance go into
 580  * the labels of a metric. */
 581 static char *metric_family_name(data_set_t const *ds, value_list_t const *vl,
 582                                 size_t ds_index) {
 583   char const *fields[5] = {"collectd"};
 584   size_t fields_num = 1;
 585
 586   if (strcmp(vl->plugin, vl->type) != 0) {
 587     fields[fields_num] = vl->plugin;
 588     fields_num++;
 589   }
 590   fields[fields_num] = vl->type;
 591   fields_num++;
 592
 593   if (strcmp("value", ds->ds[ds_index].name) != 0) {
 594     fields[fields_num] = ds->ds[ds_index].name;
 595     fields_num++;
 596   }
 597
 598   /* Prometheus best practices:
 599    * cumulative metrics should have a "total" suffix. */
 600   if ((ds->ds[ds_index].type == DS_TYPE_COUNTER) ||
 601       (ds->ds[ds_index].type == DS_TYPE_DERIVE)) {
 602     fields[fields_num] = "total";
 603     fields_num++;
 604   }
 605
 606   char name[5 * DATA_MAX_NAME_LEN];
 607   strjoin(name, sizeof(name), (char **)fields, fields_num, "_");
 608   return strdup(name);
 609 }
 610
 611 /* metric_family_get looks up the matching metric family, allocating it if
 612  * necessary. */
 613 static Io__Prometheus__Client__MetricFamily *
 614 metric_family_get(data_set_t const *ds, value_list_t const *vl,
 615                   size_t ds_index) {
 616   char *name = metric_family_name(ds, vl, ds_index);
 617   if (name == NULL) {
 618     ERROR("write_prometheus plugin: Allocating metric family name failed.");
 619     return NULL;
 620   }
 621
 622   Io__Prometheus__Client__MetricFamily *fam = NULL;
 623   if (c_avl_get(metrics, name, (void *)&fam) == 0) {
 624     sfree(name);
 625     assert(fam != NULL);
 626     return fam;
 627   }
 628
 629   fam = metric_family_create(name, ds, vl, ds_index);
 630   if (fam == NULL) {
 631     ERROR("write_prometheus plugin: Allocating metric family failed.");
 632     sfree(name);
 633     return NULL;
 634   }
 635
 636   /* If successful, "name" is owned by "fam", i.e. don't free it here. */
 637   DEBUG("write_prometheus plugin: metric family \"%s\" has been created.",
 638         name);
 639   name = NULL;
 640
 641   int status = c_avl_insert(metrics, fam->name, fam);
 642   if (status != 0) {
 643     ERROR("write_prometheus plugin: Adding \"%s\" failed.", name);
 644     metric_family_destroy(fam);
 645     return NULL;
 646   }
 647
 648   return fam;
 649 }
 650 /* }}} */
 651
 652 /*
 653  * collectd callbacks
 654  */
 655 static int prom_config(oconfig_item_t *ci) {
 656   for (int i = 0; i < ci->children_num; i++) {
 657     oconfig_item_t *child = ci->children + i;
 658
 659     if (strcasecmp("Port", child->key) == 0) {
 660       int status = cf_util_get_port_number(child);
 661       if (status > 0)
 662         httpd_port = (unsigned short)status;
 663     } else if (strcasecmp("StalenessDelta", child->key) == 0) {
 664       cf_util_get_cdtime(child, &staleness_delta);
 665     } else {
 666       WARNING("write_prometheus plugin: Ignoring unknown configuration option "
 667               "\"%s\".",
 668               child->key);
 669     }
 670   }
 671
 672   return 0;
 673 }
 674
 675 static int prom_init() {
 676   if (metrics == NULL) {
 677     metrics = c_avl_create((void *)strcmp);
 678     if (metrics == NULL) {
 679       ERROR("write_prometheus plugin: c_avl_create() failed.");
 680       return -1;
 681     }
 682   }
 683
 684   if (httpd == NULL) {
 685     unsigned int flags = MHD_USE_THREAD_PER_CONNECTION;
 686 #if MHD_VERSION >= 0x00093300
 687     flags |= MHD_USE_DUAL_STACK;
 688 #endif
 689
 690     httpd = MHD_start_daemon(flags, httpd_port,
 691                              /* MHD_AcceptPolicyCallback = */ NULL,
 692                              /* MHD_AcceptPolicyCallback arg = */ NULL,
 693                              http_handler, NULL, MHD_OPTION_END);
 694     if (httpd == NULL) {
 695       ERROR("write_prometheus plugin: MHD_start_daemon() failed.");
 696       return -1;
 697     }
 698     DEBUG("write_prometheus plugin: Successfully started microhttpd %s",
 699           MHD_get_version());
 700   }
 701
 702   return 0;
 703 }
 704
 705 static int prom_write(data_set_t const *ds, value_list_t const *vl,
 706                       __attribute__((unused)) user_data_t *ud) {
 707   pthread_mutex_lock(&metrics_lock);
 708
 709   for (size_t i = 0; i < ds->ds_num; i++) {
 710     Io__Prometheus__Client__MetricFamily *fam = metric_family_get(ds, vl, i);
 711     if (fam == NULL)
 712       continue;
 713
 714     int status = metric_family_update(fam, ds, vl, i);
 715     if (status != 0) {
 716       ERROR("write_prometheus plugin: Updating metric \"%s\" failed with "
 717             "status %d",
 718             fam->name, status);
 719       continue;
 720     }
 721   }
 722
 723   pthread_mutex_unlock(&metrics_lock);
 724   return 0;
 725 }
 726
 727 static int prom_missing(value_list_t const *vl,
 728                         __attribute__((unused)) user_data_t *ud) {
 729   data_set_t const *ds = plugin_get_ds(vl->type);
 730   if (ds == NULL)
 731     return ENOENT;
 732
 733   pthread_mutex_lock(&metrics_lock);
 734
 735   for (size_t i = 0; i < ds->ds_num; i++) {
 736     Io__Prometheus__Client__MetricFamily *fam = metric_family_get(ds, vl, i);
 737     if (fam == NULL)
 738       continue;
 739
 740     int status = metric_family_delete_metric(fam, vl);
 741     if (status != 0) {
 742       ERROR("write_prometheus plugin: Deleting a metric in family \"%s\" "
 743             "failed with status %d",
 744             fam->name, status);
 745       continue;
 746     }
 747
 748     if (fam->n_metric == 0) {
 749       int status = c_avl_remove(metrics, fam->name, NULL, NULL);
 750       if (status != 0) {
 751         ERROR("write_prometheus plugin: Deleting metric family \"%s\" failed "
 752               "with status %d",
 753               fam->name, status);
 754         continue;
 755       }
 756       metric_family_destroy(fam);
 757     }
 758   }
 759
 760   pthread_mutex_unlock(&metrics_lock);
 761   return 0;
 762 }
 763
 764 static int prom_shutdown() {
 765   if (httpd != NULL) {
 766     MHD_stop_daemon(httpd);
 767     httpd = NULL;
 768   }
 769
 770   pthread_mutex_lock(&metrics_lock);
 771   if (metrics != NULL) {
 772     char *name;
 773     Io__Prometheus__Client__MetricFamily *fam;
 774     while (c_avl_pick(metrics, (void *)&name, (void *)&fam) == 0) {
 775       assert(name == fam->name);
 776       name = NULL;
 777
 778       metric_family_destroy(fam);
 779     }
 780     c_avl_destroy(metrics);
 781     metrics = NULL;
 782   }
 783   pthread_mutex_unlock(&metrics_lock);
 784
 785   return 0;
 786 }
 787
 788 void module_register() {
 789   plugin_register_complex_config("write_prometheus", prom_config);
 790   plugin_register_init("write_prometheus", prom_init);
 791   plugin_register_write("write_prometheus", prom_write,
 792                         /* user data = */ NULL);
 793   plugin_register_missing("write_prometheus", prom_missing,
 794                           /* user data = */ NULL);
 795   plugin_register_shutdown("write_prometheus", prom_shutdown);
 796 }
 797
 798 /* vim: set sw=2 sts=2 et fdm=marker : */