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