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 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 (size_t 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
 226   memset (buffer, 0, buffer_size);
 227
 228 #define BUFFER_ADD(...) do { \
 229   status = ssnprintf (buffer + offset, buffer_size - offset, \
 230       __VA_ARGS__); \
 231   if (status < 1) \
 232     return (-1); \
 233   else if (((size_t) status) >= (buffer_size - offset)) \
 234     return (-ENOMEM); \
 235   else \
 236     offset += ((size_t) status); \
 237 } while (0)
 238
 239 #define BUFFER_ADD_KEYVAL(key, value) do { \
 240   status = kairosdb_escape_string (temp, sizeof (temp), (value)); \
 241   if (status != 0) \
 242     return (status); \
 243   BUFFER_ADD (",\"%s\": %s", (key), temp); \
 244 } while (0)
 245
 246   for (size_t i = 0; i < ds->ds_num; i++)
 247   {
 248     /* All value lists have a leading comma. The first one will be replaced with
 249      * a square bracket in `format_kairosdb_finalize'. */
 250     BUFFER_ADD (",{");
 251
 252     BUFFER_ADD ("\"name\":\"collectd");
 253
 254     BUFFER_ADD (".%s", vl->plugin);
 255
 256     status = values_to_kairosdb (temp, sizeof (temp), ds, vl, store_rates, i);
 257     if (status != 0)
 258       return (status);
 259
 260     BUFFER_ADD ("\", \"datapoints\": %s", temp);
 261
 262     /*
 263      * Now adds meta data to metric as tags
 264      */
 265
 266     memset (temp, 0, sizeof(temp));
 267
 268     BUFFER_ADD (", \"tags\":\{");
 269
 270     BUFFER_ADD ("\"host\": \"%s\"", vl->host);
 271     if (strlen(vl->plugin_instance))
 272       BUFFER_ADD_KEYVAL ("plugin_instance", vl->plugin_instance);
 273     BUFFER_ADD_KEYVAL ("type", vl->type);
 274     if (strlen(vl->type_instance))
 275       BUFFER_ADD_KEYVAL ("type_instance", vl->type_instance);
 276     if (ds->ds_num != 1)
 277       BUFFER_ADD_KEYVAL ("ds", ds->ds[i].name);
 278     BUFFER_ADD ("}}");
 279   } /* for ds->ds_num */
 280
 281 #undef BUFFER_ADD_KEYVAL
 282 #undef BUFFER_ADD
 283
 284   DEBUG ("format_kairosdb: value_list_to_kairosdb: buffer = %s;", buffer);
 285
 286   return (0);
 287 } /* }}} int value_list_to_kairosdb */
 288
 289 static int format_kairosdb_value_list_nocheck (char *buffer, /* {{{ */
 290     size_t *ret_buffer_fill, size_t *ret_buffer_free,
 291     const data_set_t *ds, const value_list_t *vl,
 292     int store_rates, size_t temp_size)
 293 {
 294   char temp[temp_size];
 295   int status;
 296
 297   status = value_list_to_kairosdb (temp, sizeof (temp), ds, vl, store_rates);
 298   if (status != 0)
 299     return (status);
 300   temp_size = strlen (temp);
 301
 302   memcpy (buffer + (*ret_buffer_fill), temp, temp_size + 1);
 303   (*ret_buffer_fill) += temp_size;
 304   (*ret_buffer_free) -= temp_size;
 305
 306   return (0);
 307 } /* }}} int format_kairosdb_value_list_nocheck */
 308
 309 int format_kairosdb_initialize (char *buffer, /* {{{ */
 310     size_t *ret_buffer_fill, size_t *ret_buffer_free)
 311 {
 312   size_t buffer_fill;
 313   size_t buffer_free;
 314
 315   if ((buffer == NULL) || (ret_buffer_fill == NULL) || (ret_buffer_free == NULL))
 316     return (-EINVAL);
 317
 318   buffer_fill = *ret_buffer_fill;
 319   buffer_free = *ret_buffer_free;
 320
 321   buffer_free = buffer_fill + buffer_free;
 322   buffer_fill = 0;
 323
 324   if (buffer_free < 3)
 325     return (-ENOMEM);
 326
 327   memset (buffer, 0, buffer_free);
 328   *ret_buffer_fill = buffer_fill;
 329   *ret_buffer_free = buffer_free;
 330
 331   return (0);
 332 } /* }}} int format_kairosdb_initialize */
 333
 334 int format_kairosdb_finalize (char *buffer, /* {{{ */
 335     size_t *ret_buffer_fill, size_t *ret_buffer_free)
 336 {
 337   size_t pos;
 338
 339   if ((buffer == NULL) || (ret_buffer_fill == NULL) || (ret_buffer_free == NULL))
 340     return (-EINVAL);
 341
 342   if (*ret_buffer_free < 2)
 343     return (-ENOMEM);
 344
 345   /* Replace the leading comma added in `value_list_to_kairosdb' with a square
 346    * bracket. */
 347   if (buffer[0] != ',')
 348     return (-EINVAL);
 349   buffer[0] = '[';
 350
 351   pos = *ret_buffer_fill;
 352   buffer[pos] = ']';
 353   buffer[pos+1] = 0;
 354
 355   (*ret_buffer_fill)++;
 356   (*ret_buffer_free)--;
 357
 358   return (0);
 359 } /* }}} int format_kairosdb_finalize */
 360
 361 int format_kairosdb_value_list (char *buffer, /* {{{ */
 362     size_t *ret_buffer_fill, size_t *ret_buffer_free,
 363     const data_set_t *ds, const value_list_t *vl, int store_rates)
 364 {
 365   if ((buffer == NULL)
 366       || (ret_buffer_fill == NULL) || (ret_buffer_free == NULL)
 367       || (ds == NULL) || (vl == NULL))
 368     return (-EINVAL);
 369
 370   if (*ret_buffer_free < 3)
 371     return (-ENOMEM);
 372
 373   return (format_kairosdb_value_list_nocheck (buffer,
 374         ret_buffer_fill, ret_buffer_free, ds, vl,
 375         store_rates, (*ret_buffer_free) - 2));
 376 } /* }}} int format_kairosdb_value_list */
 377
 378 /* vim: set sw=2 sts=2 et fdm=marker : */