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