src/csv.c

   1 /**
   2  * collectd - src/csv.c
   3  * Copyright (C) 2007-2009  Florian octo Forster
   4  * Copyright (C) 2009       Doug MacEachern
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Florian octo Forster <octo at collectd.org>
  21  *   Doug MacEachern <dougm@hyperic.com>
  22  **/
  23
  24 #include "collectd.h"
  25
  26 #include "common.h"
  27 #include "plugin.h"
  28 #include "utils_cache.h"
  29
  30 /*
  31  * Private variables
  32  */
  33 static const char *config_keys[] = {"DataDir", "StoreRates"};
  34 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
  35
  36 static char *datadir;
  37 static int store_rates;
  38 static int use_stdio;
  39
  40 static int value_list_to_string(char *buffer, int buffer_len,
  41                                 const data_set_t *ds, const value_list_t *vl) {
  42   int offset;
  43   int status;
  44   gauge_t *rates = NULL;
  45
  46   assert(0 == strcmp(ds->type, vl->type));
  47
  48   memset(buffer, '\0', buffer_len);
  49
  50   status = snprintf(buffer, buffer_len, "%.3f", CDTIME_T_TO_DOUBLE(vl->time));
  51   if ((status < 1) || (status >= buffer_len))
  52     return -1;
  53   offset = status;
  54
  55   for (size_t i = 0; i < ds->ds_num; i++) {
  56     if ((ds->ds[i].type != DS_TYPE_COUNTER) &&
  57         (ds->ds[i].type != DS_TYPE_GAUGE) &&
  58         (ds->ds[i].type != DS_TYPE_DERIVE) &&
  59         (ds->ds[i].type != DS_TYPE_ABSOLUTE)) {
  60       sfree(rates);
  61       return -1;
  62     }
  63
  64     if (ds->ds[i].type == DS_TYPE_GAUGE) {
  65       status = snprintf(buffer + offset, buffer_len - offset, ",%lf",
  66                         vl->values[i].gauge);
  67     } else if (store_rates != 0) {
  68       if (rates == NULL)
  69         rates = uc_get_rate(ds, vl);
  70       if (rates == NULL) {
  71         WARNING("csv plugin: "
  72                 "uc_get_rate failed.");
  73         return -1;
  74       }
  75       status = snprintf(buffer + offset, buffer_len - offset, ",%lf", rates[i]);
  76     } else if (ds->ds[i].type == DS_TYPE_COUNTER) {
  77       status = snprintf(buffer + offset, buffer_len - offset, ",%" PRIu64,
  78                         (uint64_t)vl->values[i].counter);
  79     } else if (ds->ds[i].type == DS_TYPE_DERIVE) {
  80       status = snprintf(buffer + offset, buffer_len - offset, ",%" PRIi64,
  81                         vl->values[i].derive);
  82     } else if (ds->ds[i].type == DS_TYPE_ABSOLUTE) {
  83       status = snprintf(buffer + offset, buffer_len - offset, ",%" PRIu64,
  84                         vl->values[i].absolute);
  85     }
  86
  87     if ((status < 1) || (status >= (buffer_len - offset))) {
  88       sfree(rates);
  89       return -1;
  90     }
  91
  92     offset += status;
  93   } /* for ds->ds_num */
  94
  95   sfree(rates);
  96   return 0;
  97 } /* int value_list_to_string */
  98
  99 static int value_list_to_filename(char *buffer, size_t buffer_size,
 100                                   value_list_t const *vl) {
 101   int status;
 102
 103   char *ptr = buffer;
 104   size_t ptr_size = buffer_size;
 105   time_t now;
 106   struct tm struct_tm;
 107
 108   if (datadir != NULL) {
 109     size_t len = strlen(datadir) + 1;
 110
 111     if (len >= ptr_size)
 112       return ENOBUFS;
 113
 114     memcpy(ptr, datadir, len);
 115     ptr[len - 1] = '/';
 116     ptr_size -= len;
 117     ptr += len;
 118   }
 119
 120   status = FORMAT_VL(ptr, ptr_size, vl);
 121   if (status != 0)
 122     return status;
 123
 124   /* Skip all the time formatting stuff when printing to STDOUT or
 125    * STDERR. */
 126   if (use_stdio)
 127     return 0;
 128
 129   ptr_size -= strlen(ptr);
 130   ptr += strlen(ptr);
 131
 132   /* "-2013-07-12" => 11 bytes */
 133   if (ptr_size < 12) {
 134     ERROR("csv plugin: Buffer too small.");
 135     return ENOMEM;
 136   }
 137
 138   /* TODO: Find a way to minimize the calls to `localtime_r',
 139    * since they are pretty expensive.. */
 140   now = time(NULL);
 141   if (localtime_r(&now, &struct_tm) == NULL) {
 142     ERROR("csv plugin: localtime_r failed");
 143     return -1;
 144   }
 145
 146   status = strftime(ptr, ptr_size, "-%Y-%m-%d", &struct_tm);
 147   if (status == 0) /* yep, it returns zero on error. */
 148   {
 149     ERROR("csv plugin: strftime failed");
 150     return -1;
 151   }
 152
 153   return 0;
 154 } /* int value_list_to_filename */
 155
 156 static int csv_create_file(const char *filename, const data_set_t *ds) {
 157   FILE *csv;
 158
 159   if (check_create_dir(filename))
 160     return -1;
 161
 162   csv = fopen(filename, "w");
 163   if (csv == NULL) {
 164     ERROR("csv plugin: fopen (%s) failed: %s", filename, STRERRNO);
 165     return -1;
 166   }
 167
 168   fprintf(csv, "epoch");
 169   for (size_t i = 0; i < ds->ds_num; i++)
 170     fprintf(csv, ",%s", ds->ds[i].name);
 171
 172   fprintf(csv, "\n");
 173   fclose(csv);
 174
 175   return 0;
 176 } /* int csv_create_file */
 177
 178 static int csv_config(const char *key, const char *value) {
 179   if (strcasecmp("DataDir", key) == 0) {
 180     if (datadir != NULL) {
 181       free(datadir);
 182       datadir = NULL;
 183     }
 184     if (strcasecmp("stdout", value) == 0) {
 185       use_stdio = 1;
 186       return 0;
 187     } else if (strcasecmp("stderr", value) == 0) {
 188       use_stdio = 2;
 189       return 0;
 190     }
 191     datadir = strdup(value);
 192     if (datadir != NULL) {
 193       int len = strlen(datadir);
 194       while ((len > 0) && (datadir[len - 1] == '/')) {
 195         len--;
 196         datadir[len] = '\0';
 197       }
 198       if (len <= 0) {
 199         free(datadir);
 200         datadir = NULL;
 201       }
 202     }
 203   } else if (strcasecmp("StoreRates", key) == 0) {
 204     if (IS_TRUE(value))
 205       store_rates = 1;
 206     else
 207       store_rates = 0;
 208   } else {
 209     return -1;
 210   }
 211   return 0;
 212 } /* int csv_config */
 213
 214 static int csv_write(const data_set_t *ds, const value_list_t *vl,
 215                      user_data_t __attribute__((unused)) * user_data) {
 216   struct stat statbuf;
 217   char filename[512];
 218   char values[4096];
 219   FILE *csv;
 220   int csv_fd;
 221   struct flock fl = {0};
 222   int status;
 223
 224   if (0 != strcmp(ds->type, vl->type)) {
 225     ERROR("csv plugin: DS type does not match value list type");
 226     return -1;
 227   }
 228
 229   status = value_list_to_filename(filename, sizeof(filename), vl);
 230   if (status != 0)
 231     return -1;
 232
 233   DEBUG("csv plugin: csv_write: filename = %s;", filename);
 234
 235   if (value_list_to_string(values, sizeof(values), ds, vl) != 0)
 236     return -1;
 237
 238   if (use_stdio) {
 239     escape_string(filename, sizeof(filename));
 240
 241     /* Replace commas by colons for PUTVAL compatible output. */
 242     for (size_t i = 0; i < sizeof(values); i++) {
 243       if (values[i] == 0)
 244         break;
 245       else if (values[i] == ',')
 246         values[i] = ':';
 247     }
 248
 249     fprintf(use_stdio == 1 ? stdout : stderr, "PUTVAL %s interval=%.3f %s\n",
 250             filename, CDTIME_T_TO_DOUBLE(vl->interval), values);
 251     return 0;
 252   }
 253
 254   if (stat(filename, &statbuf) == -1) {
 255     if (errno == ENOENT) {
 256       if (csv_create_file(filename, ds))
 257         return -1;
 258     } else {
 259       ERROR("stat(%s) failed: %s", filename, STRERRNO);
 260       return -1;
 261     }
 262   } else if (!S_ISREG(statbuf.st_mode)) {
 263     ERROR("stat(%s): Not a regular file!", filename);
 264     return -1;
 265   }
 266
 267   csv = fopen(filename, "a");
 268   if (csv == NULL) {
 269     ERROR("csv plugin: fopen (%s) failed: %s", filename, STRERRNO);
 270     return -1;
 271   }
 272   csv_fd = fileno(csv);
 273
 274   fl.l_pid = getpid();
 275   fl.l_type = F_WRLCK;
 276   fl.l_whence = SEEK_SET;
 277
 278   status = fcntl(csv_fd, F_SETLK, &fl);
 279   if (status != 0) {
 280     ERROR("csv plugin: flock (%s) failed: %s", filename, STRERRNO);
 281     fclose(csv);
 282     return -1;
 283   }
 284
 285   fprintf(csv, "%s\n", values);
 286
 287   /* The lock is implicitely released. I we don't release it explicitely
 288    * because the `FILE *' may need to flush a cache first */
 289   fclose(csv);
 290
 291   return 0;
 292 } /* int csv_write */
 293
 294 void module_register(void) {
 295   plugin_register_config("csv", csv_config, config_keys, config_keys_num);
 296   plugin_register_write("csv", csv_write, /* user_data = */ NULL);
 297 } /* void module_register */