src/rrdcached.c

   1 /**
   2  * collectd - src/rrdcached.c
   3  * Copyright (C) 2008  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <octo at verplant.org>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "plugin.h"
  24 #include "common.h"
  25 #include "utils_rrdcreate.h"
  26
  27 #undef HAVE_CONFIG_H
  28 #include <rrd.h>
  29 #include <rrd_client.h>
  30
  31 /*
  32  * Private variables
  33  */
  34 static char *datadir = NULL;
  35 static char *daemon_address = NULL;
  36 static int config_create_files = 1;
  37 static int config_collect_stats = 1;
  38 static rrdcreate_config_t rrdcreate_config =
  39 {
  40         /* stepsize = */ 0,
  41         /* heartbeat = */ 0,
  42         /* rrarows = */ 1200,
  43         /* xff = */ 0.1,
  44
  45         /* timespans = */ NULL,
  46         /* timespans_num = */ 0,
  47
  48         /* consolidation_functions = */ NULL,
  49         /* consolidation_functions_num = */ 0
  50 };
  51
  52 /*
  53  * Prototypes.
  54  */
  55 static int rc_write (const data_set_t *ds, const value_list_t *vl,
  56     user_data_t __attribute__((unused)) *user_data);
  57 static int rc_flush (__attribute__((unused)) cdtime_t timeout,
  58     const char *identifier, __attribute__((unused)) user_data_t *ud);
  59
  60 static int value_list_to_string (char *buffer, int buffer_len,
  61     const data_set_t *ds, const value_list_t *vl)
  62 {
  63   int offset;
  64   int status;
  65   int i;
  66   time_t t;
  67
  68   assert (0 == strcmp (ds->type, vl->type));
  69
  70   memset (buffer, '\0', buffer_len);
  71
  72   t = CDTIME_T_TO_TIME_T (vl->time);
  73   status = ssnprintf (buffer, buffer_len, "%lu", (unsigned long) t);
  74   if ((status < 1) || (status >= buffer_len))
  75     return (-1);
  76   offset = status;
  77
  78   for (i = 0; i < ds->ds_num; i++)
  79   {
  80     if ((ds->ds[i].type != DS_TYPE_COUNTER)
  81         && (ds->ds[i].type != DS_TYPE_GAUGE)
  82         && (ds->ds[i].type != DS_TYPE_DERIVE)
  83         && (ds->ds[i].type != DS_TYPE_ABSOLUTE))
  84       return (-1);
  85
  86     if (ds->ds[i].type == DS_TYPE_COUNTER)
  87     {
  88       status = ssnprintf (buffer + offset, buffer_len - offset,
  89           ":%llu", vl->values[i].counter);
  90     }
  91     else if (ds->ds[i].type == DS_TYPE_GAUGE)
  92     {
  93       status = ssnprintf (buffer + offset, buffer_len - offset,
  94           ":%f", vl->values[i].gauge);
  95     }
  96     else if (ds->ds[i].type == DS_TYPE_DERIVE) {
  97       status = ssnprintf (buffer + offset, buffer_len - offset,
  98           ":%"PRIi64, vl->values[i].derive);
  99     }
 100     else /* if (ds->ds[i].type == DS_TYPE_ABSOLUTE) */ {
 101       status = ssnprintf (buffer + offset, buffer_len - offset,
 102           ":%"PRIu64, vl->values[i].absolute);
 103
 104     }
 105
 106     if ((status < 1) || (status >= (buffer_len - offset)))
 107       return (-1);
 108
 109     offset += status;
 110   } /* for ds->ds_num */
 111
 112   return (0);
 113 } /* int value_list_to_string */
 114
 115 static int value_list_to_filename (char *buffer, int buffer_len,
 116     const data_set_t *ds, const value_list_t *vl)
 117 {
 118   int offset = 0;
 119   int status;
 120
 121   assert (0 == strcmp (ds->type, vl->type));
 122
 123   if (datadir != NULL)
 124   {
 125     status = ssnprintf (buffer + offset, buffer_len - offset,
 126         "%s/", datadir);
 127     if ((status < 1) || (status >= buffer_len - offset))
 128       return (-1);
 129     offset += status;
 130   }
 131
 132   status = ssnprintf (buffer + offset, buffer_len - offset,
 133       "%s/", vl->host);
 134   if ((status < 1) || (status >= buffer_len - offset))
 135     return (-1);
 136   offset += status;
 137
 138   if (strlen (vl->plugin_instance) > 0)
 139     status = ssnprintf (buffer + offset, buffer_len - offset,
 140         "%s-%s/", vl->plugin, vl->plugin_instance);
 141   else
 142     status = ssnprintf (buffer + offset, buffer_len - offset,
 143         "%s/", vl->plugin);
 144   if ((status < 1) || (status >= buffer_len - offset))
 145     return (-1);
 146   offset += status;
 147
 148   if (strlen (vl->type_instance) > 0)
 149     status = ssnprintf (buffer + offset, buffer_len - offset,
 150         "%s-%s", vl->type, vl->type_instance);
 151   else
 152     status = ssnprintf (buffer + offset, buffer_len - offset,
 153         "%s", vl->type);
 154   if ((status < 1) || (status >= buffer_len - offset))
 155     return (-1);
 156   offset += status;
 157
 158   strncpy (buffer + offset, ".rrd", buffer_len - offset);
 159   buffer[buffer_len - 1] = 0;
 160
 161   return (0);
 162 } /* int value_list_to_filename */
 163
 164 static const char *config_get_string (oconfig_item_t *ci)
 165 {
 166   if ((ci->children_num != 0) || (ci->values_num != 1)
 167       || (ci->values[0].type != OCONFIG_TYPE_STRING))
 168   {
 169     ERROR ("rrdcached plugin: %s expects a single string argument.",
 170         ci->key);
 171     return (NULL);
 172   }
 173
 174   return (ci->values[0].value.string);
 175 } /* const char *config_get_string */
 176
 177 static int rc_config (oconfig_item_t *ci)
 178 {
 179   int i;
 180
 181   for (i = 0; i < ci->children_num; ++i) {
 182     const char *key = ci->children[i].key;
 183     const char *value = config_get_string (ci->children + i);
 184
 185     if (value == NULL) /* config_get_strings prints error message */
 186       continue;
 187
 188     if (strcasecmp ("DataDir", key) == 0)
 189     {
 190       if (datadir != NULL)
 191         free (datadir);
 192       datadir = strdup (value);
 193       if (datadir != NULL)
 194       {
 195         int len = strlen (datadir);
 196         while ((len > 0) && (datadir[len - 1] == '/'))
 197         {
 198           len--;
 199           datadir[len] = '\0';
 200         }
 201         if (len <= 0)
 202         {
 203           free (datadir);
 204           datadir = NULL;
 205         }
 206       }
 207     }
 208     else if (strcasecmp ("DaemonAddress", key) == 0)
 209     {
 210       sfree (daemon_address);
 211       daemon_address = strdup (value);
 212       if (daemon_address == NULL)
 213       {
 214         ERROR ("rrdcached plugin: strdup failed.");
 215         continue;
 216       }
 217     }
 218     else if (strcasecmp ("CreateFiles", key) == 0)
 219     {
 220       if (IS_FALSE (value))
 221         config_create_files = 0;
 222       else
 223         config_create_files = 1;
 224     }
 225     else if (strcasecmp ("CollectStatistics", key) == 0)
 226     {
 227       if (IS_FALSE (value))
 228         config_collect_stats = 0;
 229       else
 230         config_collect_stats = 1;
 231     }
 232     else
 233     {
 234       WARNING ("rrdcached plugin: Ignoring invalid option %s.", key);
 235       continue;
 236     }
 237   }
 238
 239   if (daemon_address != NULL) {
 240     plugin_register_write ("rrdcached", rc_write, /* user_data = */ NULL);
 241     plugin_register_flush ("rrdcached", rc_flush, /* user_data = */ NULL);
 242   }
 243   return (0);
 244 } /* int rc_config */
 245
 246 static int rc_read (void)
 247 {
 248   int status;
 249   rrdc_stats_t *head;
 250   rrdc_stats_t *ptr;
 251
 252   value_t values[1];
 253   value_list_t vl = VALUE_LIST_INIT;
 254
 255   if (daemon_address == NULL)
 256     return (-1);
 257
 258   if (config_collect_stats == 0)
 259     return (-1);
 260
 261   vl.values = values;
 262   vl.values_len = 1;
 263
 264   if ((strncmp ("unix:", daemon_address, strlen ("unix:")) == 0)
 265       || (daemon_address[0] == '/'))
 266     sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 267   else
 268     sstrncpy (vl.host, daemon_address, sizeof (vl.host));
 269   sstrncpy (vl.plugin, "rrdcached", sizeof (vl.plugin));
 270
 271   head = NULL;
 272   status = rrdc_stats_get (&head);
 273   if (status != 0)
 274   {
 275     ERROR ("rrdcached plugin: rrdc_stats_get failed with status %i.", status);
 276     return (-1);
 277   }
 278
 279   for (ptr = head; ptr != NULL; ptr = ptr->next)
 280   {
 281     if (ptr->type == RRDC_STATS_TYPE_GAUGE)
 282       values[0].gauge = (gauge_t) ptr->value.gauge;
 283     else if (ptr->type == RRDC_STATS_TYPE_COUNTER)
 284       values[0].counter = (counter_t) ptr->value.counter;
 285     else
 286       continue;
 287
 288     if (strcasecmp ("QueueLength", ptr->name) == 0)
 289     {
 290       sstrncpy (vl.type, "queue_length", sizeof (vl.type));
 291       sstrncpy (vl.type_instance, "", sizeof (vl.type_instance));
 292     }
 293     else if (strcasecmp ("UpdatesWritten", ptr->name) == 0)
 294     {
 295       sstrncpy (vl.type, "operations", sizeof (vl.type));
 296       sstrncpy (vl.type_instance, "write-updates", sizeof (vl.type_instance));
 297     }
 298     else if (strcasecmp ("DataSetsWritten", ptr->name) == 0)
 299     {
 300       sstrncpy (vl.type, "operations", sizeof (vl.type));
 301       sstrncpy (vl.type_instance, "write-data_sets",
 302           sizeof (vl.type_instance));
 303     }
 304     else if (strcasecmp ("TreeNodesNumber", ptr->name) == 0)
 305     {
 306       sstrncpy (vl.type, "gauge", sizeof (vl.type));
 307       sstrncpy (vl.type_instance, "tree_nodes", sizeof (vl.type_instance));
 308     }
 309     else if (strcasecmp ("TreeDepth", ptr->name) == 0)
 310     {
 311       sstrncpy (vl.type, "gauge", sizeof (vl.type));
 312       sstrncpy (vl.type_instance, "tree_depth", sizeof (vl.type_instance));
 313     }
 314     else if (strcasecmp ("FlushesReceived", ptr->name) == 0)
 315     {
 316       sstrncpy (vl.type, "operations", sizeof (vl.type));
 317       sstrncpy (vl.type_instance, "receive-flush", sizeof (vl.type_instance));
 318     }
 319     else if (strcasecmp ("JournalBytes", ptr->name) == 0)
 320     {
 321       sstrncpy (vl.type, "counter", sizeof (vl.type));
 322       sstrncpy (vl.type_instance, "journal-bytes", sizeof (vl.type_instance));
 323     }
 324     else if (strcasecmp ("JournalRotate", ptr->name) == 0)
 325     {
 326       sstrncpy (vl.type, "counter", sizeof (vl.type));
 327       sstrncpy (vl.type_instance, "journal-rotates", sizeof (vl.type_instance));
 328     }
 329     else if (strcasecmp ("UpdatesReceived", ptr->name) == 0)
 330     {
 331       sstrncpy (vl.type, "operations", sizeof (vl.type));
 332       sstrncpy (vl.type_instance, "receive-update", sizeof (vl.type_instance));
 333     }
 334     else
 335     {
 336       DEBUG ("rrdcached plugin: rc_read: Unknown statistic `%s'.", ptr->name);
 337       continue;
 338     }
 339
 340     plugin_dispatch_values (&vl);
 341   } /* for (ptr = head; ptr != NULL; ptr = ptr->next) */
 342
 343   rrdc_stats_free (head);
 344
 345   return (0);
 346 } /* int rc_read */
 347
 348 static int rc_init (void)
 349 {
 350   if (config_collect_stats != 0)
 351     plugin_register_read ("rrdcached", rc_read);
 352
 353   return (0);
 354 } /* int rc_init */
 355
 356 static int rc_write (const data_set_t *ds, const value_list_t *vl,
 357     user_data_t __attribute__((unused)) *user_data)
 358 {
 359   char filename[PATH_MAX];
 360   char values[512];
 361   char *values_array[2];
 362   int status;
 363
 364   if (daemon_address == NULL)
 365   {
 366     ERROR ("rrdcached plugin: daemon_address == NULL.");
 367     plugin_unregister_write ("rrdcached");
 368     return (-1);
 369   }
 370
 371   if (strcmp (ds->type, vl->type) != 0)
 372   {
 373     ERROR ("rrdcached plugin: DS type does not match value list type");
 374     return (-1);
 375   }
 376
 377   if (value_list_to_filename (filename, sizeof (filename), ds, vl) != 0)
 378   {
 379     ERROR ("rrdcached plugin: value_list_to_filename failed.");
 380     return (-1);
 381   }
 382
 383   if (value_list_to_string (values, sizeof (values), ds, vl) != 0)
 384   {
 385     ERROR ("rrdcached plugin: value_list_to_string failed.");
 386     return (-1);
 387   }
 388
 389   values_array[0] = values;
 390   values_array[1] = NULL;
 391
 392   if (config_create_files != 0)
 393   {
 394     struct stat statbuf;
 395
 396     status = stat (filename, &statbuf);
 397     if (status != 0)
 398     {
 399       if (errno != ENOENT)
 400       {
 401         char errbuf[1024];
 402         ERROR ("rrdcached plugin: stat (%s) failed: %s",
 403             filename, sstrerror (errno, errbuf, sizeof (errbuf)));
 404         return (-1);
 405       }
 406
 407       status = cu_rrd_create_file (filename, ds, vl, &rrdcreate_config);
 408       if (status != 0)
 409       {
 410         ERROR ("rrdcached plugin: cu_rrd_create_file (%s) failed.",
 411             filename);
 412         return (-1);
 413       }
 414     }
 415   }
 416
 417   status = rrdc_connect (daemon_address);
 418   if (status != 0)
 419   {
 420     ERROR ("rrdcached plugin: rrdc_connect (%s) failed with status %i.",
 421         daemon_address, status);
 422     return (-1);
 423   }
 424
 425   status = rrdc_update (filename, /* values_num = */ 1, (void *) values_array);
 426   if (status != 0)
 427   {
 428     ERROR ("rrdcached plugin: rrdc_update (%s, [%s], 1) failed with "
 429         "status %i.",
 430         filename, values_array[0], status);
 431     return (-1);
 432   }
 433
 434   return (0);
 435 } /* int rc_write */
 436
 437 static int rc_flush (__attribute__((unused)) cdtime_t timeout, /* {{{ */
 438     const char *identifier,
 439     __attribute__((unused)) user_data_t *ud)
 440 {
 441   char filename[PATH_MAX + 1];
 442   int status;
 443
 444   if (identifier == NULL)
 445     return (EINVAL);
 446
 447   if (datadir != NULL)
 448     ssnprintf (filename, sizeof (filename), "%s/%s.rrd", datadir, identifier);
 449   else
 450     ssnprintf (filename, sizeof (filename), "%s.rrd", identifier);
 451
 452   status = rrdc_connect (daemon_address);
 453   if (status != 0)
 454   {
 455     ERROR ("rrdcached plugin: rrdc_connect (%s) failed with status %i.",
 456         daemon_address, status);
 457     return (-1);
 458   }
 459
 460   status = rrdc_flush (filename);
 461   if (status != 0)
 462   {
 463     ERROR ("rrdcached plugin: rrdc_flush (%s) failed with status %i.",
 464         filename, status);
 465     return (-1);
 466   }
 467   DEBUG ("rrdcached plugin: rrdc_flush (%s): Success.", filename);
 468
 469   return (0);
 470 } /* }}} int rc_flush */
 471
 472 static int rc_shutdown (void)
 473 {
 474   rrdc_disconnect ();
 475   return (0);
 476 } /* int rc_shutdown */
 477
 478 void module_register (void)
 479 {
 480   plugin_register_complex_config ("rrdcached", rc_config);
 481   plugin_register_init ("rrdcached", rc_init);
 482   plugin_register_shutdown ("rrdcached", rc_shutdown);
 483 } /* void module_register */
 484
 485 /*
 486  * vim: set sw=2 sts=2 et :
 487  */