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 "plugin.h"
27 #include "utils/common/common.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
value_list_to_string(char * buffer,int buffer_len,const data_set_t * ds,const value_list_t * vl)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
value_list_to_filename(char * buffer,size_t buffer_size,value_list_t const * vl)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
csv_create_file(const char * filename,const data_set_t * ds)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
csv_config(const char * key,const char * value)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 size_t 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
csv_write(const data_set_t * ds,const value_list_t * vl,user_data_t * user_data)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
module_register(void)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 */
298