src/utils_format_kairosdb.c

   1 /**
   2  * collectd - src/utils_format_kairosdb.c
   3  * Copyright (C) 2016       Aurelien beorn Rougemont
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is 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
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Aurelien beorn Rougemont <beorn at gandi dot net>
  25  **/
  26
  27 #include "collectd.h"
  28
  29 #include "common.h"
  30 #include "plugin.h"
  31
  32 #include "utils_cache.h"
  33 #include "utils_format_kairosdb.h"
  34
  35 /* This is the KAIROSDB format for write_http output
  36  *
  37  * Target format
  38  * [
  39  *   {
  40  *     "name":"collectd.vmem"
  41  *     "datapoints":
  42  *       [
  43  *         [1453897164060, 97.000000]
  44  *       ],
  45  *      "tags":
  46  *        {
  47  *          "host": "fqdn.domain.tld",
  48  *          "plugin_instance": "vmpage_number",
  49  *          "type": "kernel_stack",
  50  *          "ds": "value"
  51  *          ""
  52  *        }
  53  *   }
  54  * ]
  55  */
  56
  57 static int kairosdb_escape_string(char *buffer, size_t buffer_size, /* {{{ */
  58                                   const char *string) {
  59   size_t dst_pos;
  60
  61   if ((buffer == NULL) || (string == NULL))
  62     return (-EINVAL);
  63
  64   if (buffer_size < 3)
  65     return (-ENOMEM);
  66
  67   dst_pos = 0;
  68
  69 #define BUFFER_ADD(c)                                                          \
  70   do {                                                                         \
  71     if (dst_pos >= (buffer_size - 1)) {                                        \
  72       buffer[buffer_size - 1] = 0;                                             \
  73       return (-ENOMEM);                                                        \
  74     }                                                                          \
  75     buffer[dst_pos] = (c);                                                     \
  76     dst_pos++;                                                                 \
  77   } while (0)
  78
  79   /* Escape special characters */
  80   /* authorize -_. and alpha num but also escapes " */
  81   BUFFER_ADD('"');
  82   for (size_t src_pos = 0; string[src_pos] != 0; src_pos++) {
  83     if (isalnum(string[src_pos]) || 0x2d == string[src_pos] ||
  84         0x2e == string[src_pos] || 0x5f == string[src_pos])
  85       BUFFER_ADD(tolower(string[src_pos]));
  86   } /* for */
  87   BUFFER_ADD('"');
  88   buffer[dst_pos] = 0;
  89
  90 #undef BUFFER_ADD
  91
  92   return (0);
  93 } /* }}} int kairosdb_escape_string */
  94
  95 static int values_to_kairosdb(char *buffer, size_t buffer_size, /* {{{ */
  96                               const data_set_t *ds, const value_list_t *vl,
  97                               int store_rates, size_t ds_idx) {
  98   size_t offset = 0;
  99   gauge_t *rates = NULL;
 100
 101   memset(buffer, 0, buffer_size);
 102
 103 #define BUFFER_ADD(...)                                                        \
 104   do {                                                                         \
 105     int status;                                                                \
 106     status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);    \
 107     if (status < 1) {                                                          \
 108       sfree(rates);                                                            \
 109       return (-1);                                                             \
 110     } else if (((size_t)status) >= (buffer_size - offset)) {                   \
 111       sfree(rates);                                                            \
 112       return (-ENOMEM);                                                        \
 113     } else                                                                     \
 114       offset += ((size_t)status);                                              \
 115   } while (0)
 116
 117   if (ds->ds[ds_idx].type == DS_TYPE_GAUGE) {
 118     if (isfinite(vl->values[ds_idx].gauge)) {
 119       BUFFER_ADD("[[");
 120       BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
 121       BUFFER_ADD(",");
 122       BUFFER_ADD(JSON_GAUGE_FORMAT, vl->values[ds_idx].gauge);
 123     } else {
 124       DEBUG("utils_format_kairosdb: invalid vl->values[ds_idx].gauge for "
 125             "%s|%s|%s|%s|%s",
 126             vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
 127             ds->ds[ds_idx].name);
 128       return (-1);
 129     }
 130   } else if (store_rates) {
 131     if (rates == NULL)
 132       rates = uc_get_rate(ds, vl);
 133     if (rates == NULL) {
 134       WARNING("utils_format_kairosdb: uc_get_rate failed for %s|%s|%s|%s|%s",
 135               vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
 136               ds->ds[ds_idx].name);
 137
 138       return (-1);
 139     }
 140
 141     if (isfinite(rates[ds_idx])) {
 142       BUFFER_ADD("[[");
 143       BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
 144       BUFFER_ADD(",");
 145       BUFFER_ADD(JSON_GAUGE_FORMAT, rates[ds_idx]);
 146     } else {
 147       WARNING("utils_format_kairosdb: invalid rates[ds_idx] for %s|%s|%s|%s|%s",
 148               vl->plugin, vl->plugin_instance, vl->type, vl->type_instance,
 149               ds->ds[ds_idx].name);
 150       sfree(rates);
 151       return (-1);
 152     }
 153   } else if (ds->ds[ds_idx].type == DS_TYPE_COUNTER) {
 154     BUFFER_ADD("[[");
 155     BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
 156     BUFFER_ADD(",");
 157     BUFFER_ADD("%llu", vl->values[ds_idx].counter);
 158   } else if (ds->ds[ds_idx].type == DS_TYPE_DERIVE) {
 159     BUFFER_ADD("[[");
 160     BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
 161     BUFFER_ADD(",");
 162     BUFFER_ADD("%" PRIi64, vl->values[ds_idx].derive);
 163   } else if (ds->ds[ds_idx].type == DS_TYPE_ABSOLUTE) {
 164     BUFFER_ADD("[[");
 165     BUFFER_ADD("%" PRIu64, CDTIME_T_TO_MS(vl->time));
 166     BUFFER_ADD(",");
 167     BUFFER_ADD("%" PRIu64, vl->values[ds_idx].absolute);
 168   } else {
 169     ERROR("format_kairosdb: Unknown data source type: %i", ds->ds[ds_idx].type);
 170     sfree(rates);
 171     return (-1);
 172   }
 173   BUFFER_ADD("]]");
 174
 175 #undef BUFFER_ADD
 176
 177   DEBUG("format_kairosdb: values_to_kairosdb: buffer = %s;", buffer);
 178   sfree(rates);
 179   return (0);
 180 } /* }}} int values_to_kairosdb */
 181
 182 static int value_list_to_kairosdb(char *buffer, size_t buffer_size, /* {{{ */
 183                                   const data_set_t *ds, const value_list_t *vl,
 184                                   int store_rates,
 185                                   char const *const *http_attrs,
 186                                   size_t http_attrs_num) {
 187   char temp[512];
 188   size_t offset = 0;
 189   int status;
 190
 191   memset(buffer, 0, buffer_size);
 192
 193 #define BUFFER_ADD(...)                                                        \
 194   do {                                                                         \
 195     status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);    \
 196     if (status < 1)                                                            \
 197       return (-1);                                                             \
 198     else if (((size_t)status) >= (buffer_size - offset))                       \
 199       return (-ENOMEM);                                                        \
 200     else                                                                       \
 201       offset += ((size_t)status);                                              \
 202   } while (0)
 203
 204 #define BUFFER_ADD_KEYVAL(key, value)                                          \
 205   do {                                                                         \
 206     status = kairosdb_escape_string(temp, sizeof(temp), (value));              \
 207     if (status != 0)                                                           \
 208       return (status);                                                         \
 209     BUFFER_ADD(",\"%s\": %s", (key), temp);                                    \
 210   } while (0)
 211
 212   for (size_t i = 0; i < ds->ds_num; i++) {
 213     /* All value lists have a leading comma. The first one will be replaced with
 214      * a square bracket in `format_kairosdb_finalize'. */
 215     BUFFER_ADD(",{");
 216
 217     BUFFER_ADD("\"name\":\"collectd");
 218
 219     BUFFER_ADD(".%s", vl->plugin);
 220
 221     status = values_to_kairosdb(temp, sizeof(temp), ds, vl, store_rates, i);
 222     if (status != 0)
 223       return (status);
 224
 225     BUFFER_ADD("\", \"datapoints\": %s", temp);
 226
 227     /*
 228      * Now adds meta data to metric as tags
 229      */
 230
 231     memset(temp, 0, sizeof(temp));
 232
 233     BUFFER_ADD(", \"tags\":\{");
 234
 235     BUFFER_ADD("\"host\": \"%s\"", vl->host);
 236     for (size_t j = 0; j < http_attrs_num; j += 2) {
 237       BUFFER_ADD(", \"%s\":", http_attrs[j]);
 238       BUFFER_ADD(" \"%s\"", http_attrs[j + 1]);
 239     }
 240
 241     if (strlen(vl->plugin_instance))
 242       BUFFER_ADD_KEYVAL("plugin_instance", vl->plugin_instance);
 243     BUFFER_ADD_KEYVAL("type", vl->type);
 244     if (strlen(vl->type_instance))
 245       BUFFER_ADD_KEYVAL("type_instance", vl->type_instance);
 246     if (ds->ds_num != 1)
 247       BUFFER_ADD_KEYVAL("ds", ds->ds[i].name);
 248     BUFFER_ADD("}}");
 249   } /* for ds->ds_num */
 250
 251 #undef BUFFER_ADD_KEYVAL
 252 #undef BUFFER_ADD
 253
 254   DEBUG("format_kairosdb: value_list_to_kairosdb: buffer = %s;", buffer);
 255
 256   return (0);
 257 } /* }}} int value_list_to_kairosdb */
 258
 259 static int format_kairosdb_value_list_nocheck(
 260     char *buffer, /* {{{ */
 261     size_t *ret_buffer_fill, size_t *ret_buffer_free, const data_set_t *ds,
 262     const value_list_t *vl, int store_rates, size_t temp_size,
 263     char const *const *http_attrs, size_t http_attrs_num) {
 264   char temp[temp_size];
 265   int status;
 266
 267   status = value_list_to_kairosdb(temp, sizeof(temp), ds, vl, store_rates,
 268                                   http_attrs, http_attrs_num);
 269   if (status != 0)
 270     return (status);
 271   temp_size = strlen(temp);
 272
 273   memcpy(buffer + (*ret_buffer_fill), temp, temp_size + 1);
 274   (*ret_buffer_fill) += temp_size;
 275   (*ret_buffer_free) -= temp_size;
 276
 277   return (0);
 278 } /* }}} int format_kairosdb_value_list_nocheck */
 279
 280 int format_kairosdb_initialize(char *buffer, /* {{{ */
 281                                size_t *ret_buffer_fill,
 282                                size_t *ret_buffer_free) {
 283   size_t buffer_fill;
 284   size_t buffer_free;
 285
 286   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
 287       (ret_buffer_free == NULL))
 288     return (-EINVAL);
 289
 290   buffer_fill = *ret_buffer_fill;
 291   buffer_free = *ret_buffer_free;
 292
 293   buffer_free = buffer_fill + buffer_free;
 294   buffer_fill = 0;
 295
 296   if (buffer_free < 3)
 297     return (-ENOMEM);
 298
 299   memset(buffer, 0, buffer_free);
 300   *ret_buffer_fill = buffer_fill;
 301   *ret_buffer_free = buffer_free;
 302
 303   return (0);
 304 } /* }}} int format_kairosdb_initialize */
 305
 306 int format_kairosdb_finalize(char *buffer, /* {{{ */
 307                              size_t *ret_buffer_fill, size_t *ret_buffer_free) {
 308   size_t pos;
 309
 310   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
 311       (ret_buffer_free == NULL))
 312     return (-EINVAL);
 313
 314   if (*ret_buffer_free < 2)
 315     return (-ENOMEM);
 316
 317   /* Replace the leading comma added in `value_list_to_kairosdb' with a square
 318    * bracket. */
 319   if (buffer[0] != ',')
 320     return (-EINVAL);
 321   buffer[0] = '[';
 322
 323   pos = *ret_buffer_fill;
 324   buffer[pos] = ']';
 325   buffer[pos + 1] = 0;
 326
 327   (*ret_buffer_fill)++;
 328   (*ret_buffer_free)--;
 329
 330   return (0);
 331 } /* }}} int format_kairosdb_finalize */
 332
 333 int format_kairosdb_value_list(char *buffer, /* {{{ */
 334                                size_t *ret_buffer_fill, size_t *ret_buffer_free,
 335                                const data_set_t *ds, const value_list_t *vl,
 336                                int store_rates, char const *const *http_attrs,
 337                                size_t http_attrs_num) {
 338   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
 339       (ret_buffer_free == NULL) || (ds == NULL) || (vl == NULL))
 340     return (-EINVAL);
 341
 342   if (*ret_buffer_free < 3)
 343     return (-ENOMEM);
 344
 345   return (format_kairosdb_value_list_nocheck(
 346       buffer, ret_buffer_fill, ret_buffer_free, ds, vl, store_rates,
 347       (*ret_buffer_free) - 2, http_attrs, http_attrs_num));
 348 } /* }}} int format_kairosdb_value_list */
 349
 350 /* vim: set sw=2 sts=2 et fdm=marker : */