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 temp[512];
 186   size_t offset = 0;
 187   int status;
 188
 189   memset(buffer, 0, buffer_size);
 190
 191 #define BUFFER_ADD(...)                                                        \
 192   do {                                                                         \
 193     status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);    \
 194     if (status < 1)                                                            \
 195       return (-1);                                                             \
 196     else if (((size_t)status) >= (buffer_size - offset))                       \
 197       return (-ENOMEM);                                                        \
 198     else                                                                       \
 199       offset += ((size_t)status);                                              \
 200   } while (0)
 201
 202 #define BUFFER_ADD_KEYVAL(key, value)                                          \
 203   do {                                                                         \
 204     status = kairosdb_escape_string(temp, sizeof(temp), (value));              \
 205     if (status != 0)                                                           \
 206       return (status);                                                         \
 207     BUFFER_ADD(",\"%s\": %s", (key), temp);                                    \
 208   } while (0)
 209
 210   for (size_t i = 0; i < ds->ds_num; i++) {
 211     /* All value lists have a leading comma. The first one will be replaced with
 212      * a square bracket in `format_kairosdb_finalize'. */
 213     BUFFER_ADD(",{");
 214
 215     BUFFER_ADD("\"name\":\"collectd");
 216
 217     BUFFER_ADD(".%s", vl->plugin);
 218
 219     status = values_to_kairosdb(temp, sizeof(temp), ds, vl, store_rates, i);
 220     if (status != 0)
 221       return (status);
 222
 223     BUFFER_ADD("\", \"datapoints\": %s", temp);
 224
 225     /*
 226      * Now adds meta data to metric as tags
 227      */
 228
 229     memset(temp, 0, sizeof(temp));
 230
 231     BUFFER_ADD(", \"tags\":\{");
 232
 233     BUFFER_ADD("\"host\": \"%s\"", vl->host);
 234     if (strlen(vl->plugin_instance))
 235       BUFFER_ADD_KEYVAL("plugin_instance", vl->plugin_instance);
 236     BUFFER_ADD_KEYVAL("type", vl->type);
 237     if (strlen(vl->type_instance))
 238       BUFFER_ADD_KEYVAL("type_instance", vl->type_instance);
 239     if (ds->ds_num != 1)
 240       BUFFER_ADD_KEYVAL("ds", ds->ds[i].name);
 241     BUFFER_ADD("}}");
 242   } /* for ds->ds_num */
 243
 244 #undef BUFFER_ADD_KEYVAL
 245 #undef BUFFER_ADD
 246
 247   DEBUG("format_kairosdb: value_list_to_kairosdb: buffer = %s;", buffer);
 248
 249   return (0);
 250 } /* }}} int value_list_to_kairosdb */
 251
 252 static int format_kairosdb_value_list_nocheck(
 253     char *buffer, /* {{{ */
 254     size_t *ret_buffer_fill, size_t *ret_buffer_free, const data_set_t *ds,
 255     const value_list_t *vl, int store_rates, size_t temp_size) {
 256   char temp[temp_size];
 257   int status;
 258
 259   status = value_list_to_kairosdb(temp, sizeof(temp), ds, vl, store_rates);
 260   if (status != 0)
 261     return (status);
 262   temp_size = strlen(temp);
 263
 264   memcpy(buffer + (*ret_buffer_fill), temp, temp_size + 1);
 265   (*ret_buffer_fill) += temp_size;
 266   (*ret_buffer_free) -= temp_size;
 267
 268   return (0);
 269 } /* }}} int format_kairosdb_value_list_nocheck */
 270
 271 int format_kairosdb_initialize(char *buffer, /* {{{ */
 272                                size_t *ret_buffer_fill,
 273                                size_t *ret_buffer_free) {
 274   size_t buffer_fill;
 275   size_t buffer_free;
 276
 277   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
 278       (ret_buffer_free == NULL))
 279     return (-EINVAL);
 280
 281   buffer_fill = *ret_buffer_fill;
 282   buffer_free = *ret_buffer_free;
 283
 284   buffer_free = buffer_fill + buffer_free;
 285   buffer_fill = 0;
 286
 287   if (buffer_free < 3)
 288     return (-ENOMEM);
 289
 290   memset(buffer, 0, buffer_free);
 291   *ret_buffer_fill = buffer_fill;
 292   *ret_buffer_free = buffer_free;
 293
 294   return (0);
 295 } /* }}} int format_kairosdb_initialize */
 296
 297 int format_kairosdb_finalize(char *buffer, /* {{{ */
 298                              size_t *ret_buffer_fill, size_t *ret_buffer_free) {
 299   size_t pos;
 300
 301   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
 302       (ret_buffer_free == NULL))
 303     return (-EINVAL);
 304
 305   if (*ret_buffer_free < 2)
 306     return (-ENOMEM);
 307
 308   /* Replace the leading comma added in `value_list_to_kairosdb' with a square
 309    * bracket. */
 310   if (buffer[0] != ',')
 311     return (-EINVAL);
 312   buffer[0] = '[';
 313
 314   pos = *ret_buffer_fill;
 315   buffer[pos] = ']';
 316   buffer[pos + 1] = 0;
 317
 318   (*ret_buffer_fill)++;
 319   (*ret_buffer_free)--;
 320
 321   return (0);
 322 } /* }}} int format_kairosdb_finalize */
 323
 324 int format_kairosdb_value_list(char *buffer, /* {{{ */
 325                                size_t *ret_buffer_fill, size_t *ret_buffer_free,
 326                                const data_set_t *ds, const value_list_t *vl,
 327                                int store_rates) {
 328   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
 329       (ret_buffer_free == NULL) || (ds == NULL) || (vl == NULL))
 330     return (-EINVAL);
 331
 332   if (*ret_buffer_free < 3)
 333     return (-ENOMEM);
 334
 335   return (format_kairosdb_value_list_nocheck(
 336       buffer, ret_buffer_fill, ret_buffer_free, ds, vl, store_rates,
 337       (*ret_buffer_free) - 2));
 338 } /* }}} int format_kairosdb_value_list */