Debian Codegraph @

src/write_graphite.c

raw
1 /**
2 * collectd - src/write_graphite.c
3 * Copyright (C) 2012 Pierre-Yves Ritschard
4 * Copyright (C) 2011 Scott Sanders
5 * Copyright (C) 2009 Paul Sadauskas
6 * Copyright (C) 2009 Doug MacEachern
7 * Copyright (C) 2007-2013 Florian octo Forster
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; only version 2 of the License is applicable.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Authors:
23 * Florian octo Forster <octo at collectd.org>
24 * Doug MacEachern <dougm at hyperic.com>
25 * Paul Sadauskas <psadauskas at gmail.com>
26 * Scott Sanders <scott at jssjr.com>
27 * Pierre-Yves Ritschard <pyr at spootnik.org>
28 *
29 * Based on the write_http plugin.
30 **/
31
32 /* write_graphite plugin configuration example
33 *
34 * <Plugin write_graphite>
35 * <Carbon>
36 * Host "localhost"
37 * Port "2003"
38 * Protocol "udp"
39 * LogSendErrors true
40 * Prefix "collectd"
41 * UseTags true
42 * ReverseHost false
43 * </Carbon>
44 * </Plugin>
45 */
46
47 #include "collectd.h"
48
49 #include "plugin.h"
50 #include "utils/common/common.h"
51
52 #include "utils/format_graphite/format_graphite.h"
53 #include "utils_complain.h"
54
55 #include <netdb.h>
56
57 #ifndef WG_DEFAULT_NODE
58 #define WG_DEFAULT_NODE "localhost"
59 #endif
60
61 #ifndef WG_DEFAULT_SERVICE
62 #define WG_DEFAULT_SERVICE "2003"
63 #endif
64
65 #ifndef WG_DEFAULT_PROTOCOL
66 #define WG_DEFAULT_PROTOCOL "tcp"
67 #endif
68
69 #ifndef WG_DEFAULT_LOG_SEND_ERRORS
70 #define WG_DEFAULT_LOG_SEND_ERRORS true
71 #endif
72
73 #ifndef WG_DEFAULT_ESCAPE
74 #define WG_DEFAULT_ESCAPE '_'
75 #endif
76
77 /* Ethernet - (IPv6 + TCP) = 1500 - (40 + 32) = 1428 */
78 #ifndef WG_SEND_BUF_SIZE
79 #define WG_SEND_BUF_SIZE 1428
80 #endif
81
82 #ifndef WG_MIN_RECONNECT_INTERVAL
83 #define WG_MIN_RECONNECT_INTERVAL TIME_T_TO_CDTIME_T(1)
84 #endif
85
86 /*
87 * Private variables
88 */
89 struct wg_callback {
90 int sock_fd;
91
92 char *name;
93
94 char *node;
95 char *service;
96 char *protocol;
97 bool log_send_errors;
98 char *prefix;
99 char *postfix;
100 char escape_char;
101
102 unsigned int format_flags;
103
104 char send_buf[WG_SEND_BUF_SIZE];
105 size_t send_buf_free;
106 size_t send_buf_fill;
107 cdtime_t send_buf_init_time;
108
109 pthread_mutex_t send_lock;
110 c_complain_t init_complaint;
111 cdtime_t last_connect_time;
112
113 /* Force reconnect useful for load balanced environments */
114 cdtime_t last_reconnect_time;
115 cdtime_t reconnect_interval;
116 bool reconnect_interval_reached;
117 };
118
119 /* wg_force_reconnect_check closes cb->sock_fd when it was open for longer
120 * than cb->reconnect_interval. Must hold cb->send_lock when calling. */
121 static void wg_force_reconnect_check(struct wg_callback *cb) {
122 cdtime_t now;
123
124 if (cb->reconnect_interval == 0)
125 return;
126
127 /* check if address changes if addr_timeout */
128 now = cdtime();
129 if ((now - cb->last_reconnect_time) < cb->reconnect_interval)
130 return;
131
132 /* here we should close connection on next */
133 close(cb->sock_fd);
134 cb->sock_fd = -1;
135 cb->last_reconnect_time = now;
136 cb->reconnect_interval_reached = true;
137
138 INFO("write_graphite plugin: Connection closed after %.3f seconds.",
139 CDTIME_T_TO_DOUBLE(now - cb->last_reconnect_time));
140 }
141
142 /*
143 * Functions
144 */
145 static void wg_reset_buffer(struct wg_callback *cb) {
146 memset(cb->send_buf, 0, sizeof(cb->send_buf));
147 cb->send_buf_free = sizeof(cb->send_buf);
148 cb->send_buf_fill = 0;
149 cb->send_buf_init_time = cdtime();
150 }
151
152 static int wg_send_buffer(struct wg_callback *cb) {
153 ssize_t status;
154
155 if (cb->sock_fd < 0)
156 return -1;
157
158 status = swrite(cb->sock_fd, cb->send_buf, strlen(cb->send_buf));
159 if (status != 0) {
160 if (cb->log_send_errors) {
161 ERROR("write_graphite plugin: send to %s:%s (%s) failed with status %zi "
162 "(%s)",
163 cb->node, cb->service, cb->protocol, status, STRERRNO);
164 }
165
166 close(cb->sock_fd);
167 cb->sock_fd = -1;
168
169 return -1;
170 }
171
172 return 0;
173 }
174
175 /* NOTE: You must hold cb->send_lock when calling this function! */
176 static int wg_flush_nolock(cdtime_t timeout, struct wg_callback *cb) {
177 int status;
178
179 DEBUG("write_graphite plugin: wg_flush_nolock: timeout = %.3f; "
180 "send_buf_fill = %" PRIsz ";",
181 (double)timeout, cb->send_buf_fill);
182
183 /* timeout == 0 => flush unconditionally */
184 if (timeout > 0) {
185 cdtime_t now;
186
187 now = cdtime();
188 if ((cb->send_buf_init_time + timeout) > now)
189 return 0;
190 }
191
192 if (cb->send_buf_fill == 0) {
193 cb->send_buf_init_time = cdtime();
194 return 0;
195 }
196
197 status = wg_send_buffer(cb);
198 wg_reset_buffer(cb);
199
200 return status;
201 }
202
203 static int wg_callback_init(struct wg_callback *cb) {
204 struct addrinfo *ai_list;
205 cdtime_t now;
206 int status;
207
208 char connerr[1024] = "";
209
210 if (cb->sock_fd > 0)
211 return 0;
212
213 /* Don't try to reconnect too often. By default, one reconnection attempt
214 * is made per second. */
215 now = cdtime();
216 if ((now - cb->last_connect_time) < WG_MIN_RECONNECT_INTERVAL)
217 return EAGAIN;
218 cb->last_connect_time = now;
219
220 struct addrinfo ai_hints = {.ai_family = AF_UNSPEC,
221 .ai_flags = AI_ADDRCONFIG};
222
223 if (0 == strcasecmp("tcp", cb->protocol))
224 ai_hints.ai_socktype = SOCK_STREAM;
225 else
226 ai_hints.ai_socktype = SOCK_DGRAM;
227
228 status = getaddrinfo(cb->node, cb->service, &ai_hints, &ai_list);
229 if (status != 0) {
230 ERROR("write_graphite plugin: getaddrinfo (%s, %s, %s) failed: %s",
231 cb->node, cb->service, cb->protocol, gai_strerror(status));
232 return -1;
233 }
234
235 assert(ai_list != NULL);
236 for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
237 ai_ptr = ai_ptr->ai_next) {
238 cb->sock_fd =
239 socket(ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
240 if (cb->sock_fd < 0) {
241 snprintf(connerr, sizeof(connerr), "failed to open socket: %s", STRERRNO);
242 continue;
243 }
244
245 set_sock_opts(cb->sock_fd);
246
247 status = connect(cb->sock_fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
248 if (status != 0) {
249 snprintf(connerr, sizeof(connerr), "failed to connect to remote host: %s",
250 STRERRNO);
251 close(cb->sock_fd);
252 cb->sock_fd = -1;
253 continue;
254 }
255
256 break;
257 }
258
259 freeaddrinfo(ai_list);
260
261 if (cb->sock_fd < 0) {
262 c_complain(LOG_ERR, &cb->init_complaint,
263 "write_graphite plugin: Connecting to %s:%s via %s failed. "
264 "The last error was: %s",
265 cb->node, cb->service, cb->protocol, connerr);
266 return -1;
267 } else {
268 c_release(LOG_INFO, &cb->init_complaint,
269 "write_graphite plugin: Successfully connected to %s:%s via %s.",
270 cb->node, cb->service, cb->protocol);
271 }
272
273 /* wg_force_reconnect_check does not flush the buffer before closing a
274 * sending socket, so only call wg_reset_buffer() if the socket was closed
275 * for a different reason (tracked in cb->reconnect_interval_reached). */
276 if (!cb->reconnect_interval_reached || (cb->send_buf_free == 0))
277 wg_reset_buffer(cb);
278 else
279 cb->reconnect_interval_reached = false;
280
281 return 0;
282 }
283
284 static void wg_callback_free(void *data) {
285 struct wg_callback *cb;
286
287 if (data == NULL)
288 return;
289
290 cb = data;
291
292 pthread_mutex_lock(&cb->send_lock);
293
294 wg_flush_nolock(/* timeout = */ 0, cb);
295
296 if (cb->sock_fd >= 0) {
297 close(cb->sock_fd);
298 cb->sock_fd = -1;
299 }
300
301 sfree(cb->name);
302 sfree(cb->node);
303 sfree(cb->protocol);
304 sfree(cb->service);
305 sfree(cb->prefix);
306 sfree(cb->postfix);
307
308 pthread_mutex_unlock(&cb->send_lock);
309 pthread_mutex_destroy(&cb->send_lock);
310
311 sfree(cb);
312 }
313
314 static int wg_flush(cdtime_t timeout,
315 const char *identifier __attribute__((unused)),
316 user_data_t *user_data) {
317 struct wg_callback *cb;
318 int status;
319
320 if (user_data == NULL)
321 return -EINVAL;
322
323 cb = user_data->data;
324
325 pthread_mutex_lock(&cb->send_lock);
326
327 if (cb->sock_fd < 0) {
328 status = wg_callback_init(cb);
329 if (status != 0) {
330 /* An error message has already been printed. */
331 pthread_mutex_unlock(&cb->send_lock);
332 return -1;
333 }
334 }
335
336 status = wg_flush_nolock(timeout, cb);
337 pthread_mutex_unlock(&cb->send_lock);
338
339 return status;
340 }
341
342 static int wg_send_message(char const *message, struct wg_callback *cb) {
343 int status;
344 size_t message_len;
345
346 message_len = strlen(message);
347
348 pthread_mutex_lock(&cb->send_lock);
349
350 wg_force_reconnect_check(cb);
351
352 if (cb->sock_fd < 0) {
353 status = wg_callback_init(cb);
354 if (status != 0) {
355 /* An error message has already been printed. */
356 pthread_mutex_unlock(&cb->send_lock);
357 return -1;
358 }
359 }
360
361 if (message_len >= cb->send_buf_free) {
362 status = wg_flush_nolock(/* timeout = */ 0, cb);
363 if (status != 0) {
364 pthread_mutex_unlock(&cb->send_lock);
365 return status;
366 }
367 }
368
369 /* Assert that we have enough space for this message. */
370 assert(message_len < cb->send_buf_free);
371
372 /* `message_len + 1' because `message_len' does not include the
373 * trailing null byte. Neither does `send_buffer_fill'. */
374 memcpy(cb->send_buf + cb->send_buf_fill, message, message_len + 1);
375 cb->send_buf_fill += message_len;
376 cb->send_buf_free -= message_len;
377
378 DEBUG("write_graphite plugin: [%s]:%s (%s) buf %" PRIsz "/%" PRIsz
379 " (%.1f %%) \"%s\"",
380 cb->node, cb->service, cb->protocol, cb->send_buf_fill,
381 sizeof(cb->send_buf),
382 100.0 * ((double)cb->send_buf_fill) / ((double)sizeof(cb->send_buf)),
383 message);
384
385 pthread_mutex_unlock(&cb->send_lock);
386
387 return 0;
388 }
389
390 static int wg_write_messages(const data_set_t *ds, const value_list_t *vl,
391 struct wg_callback *cb) {
392 char buffer[WG_SEND_BUF_SIZE] = {0};
393 int status;
394
395 if (0 != strcmp(ds->type, vl->type)) {
396 ERROR("write_graphite plugin: DS type does not match "
397 "value list type");
398 return -1;
399 }
400
401 status = format_graphite(buffer, sizeof(buffer), ds, vl, cb->prefix,
402 cb->postfix, cb->escape_char, cb->format_flags);
403 if (status != 0) /* error message has been printed already. */
404 return status;
405
406 /* Send the message to graphite */
407 status = wg_send_message(buffer, cb);
408 if (status != 0) /* error message has been printed already. */
409 return status;
410
411 return 0;
412 } /* int wg_write_messages */
413
414 static int wg_write(const data_set_t *ds, const value_list_t *vl,
415 user_data_t *user_data) {
416 struct wg_callback *cb;
417 int status;
418
419 if (user_data == NULL)
420 return EINVAL;
421
422 cb = user_data->data;
423
424 status = wg_write_messages(ds, vl, cb);
425
426 return status;
427 }
428
429 static int config_set_char(char *dest, oconfig_item_t *ci) {
430 char buffer[4] = {0};
431 int status;
432
433 status = cf_util_get_string_buffer(ci, buffer, sizeof(buffer));
434 if (status != 0)
435 return status;
436
437 if (buffer[0] == 0) {
438 ERROR("write_graphite plugin: Cannot use an empty string for the "
439 "\"EscapeCharacter\" option.");
440 return -1;
441 }
442
443 if (buffer[1] != 0) {
444 WARNING("write_graphite plugin: Only the first character of the "
445 "\"EscapeCharacter\" option ('%c') will be used.",
446 (int)buffer[0]);
447 }
448
449 *dest = buffer[0];
450
451 return 0;
452 }
453
454 static int wg_config_node(oconfig_item_t *ci) {
455 struct wg_callback *cb;
456 char callback_name[DATA_MAX_NAME_LEN];
457 int status = 0;
458
459 cb = calloc(1, sizeof(*cb));
460 if (cb == NULL) {
461 ERROR("write_graphite plugin: calloc failed.");
462 return -1;
463 }
464 cb->sock_fd = -1;
465 cb->name = NULL;
466 cb->node = strdup(WG_DEFAULT_NODE);
467 cb->service = strdup(WG_DEFAULT_SERVICE);
468 cb->protocol = strdup(WG_DEFAULT_PROTOCOL);
469 cb->last_reconnect_time = cdtime();
470 cb->reconnect_interval = 0;
471 cb->reconnect_interval_reached = false;
472 cb->log_send_errors = WG_DEFAULT_LOG_SEND_ERRORS;
473 cb->prefix = NULL;
474 cb->postfix = NULL;
475 cb->escape_char = WG_DEFAULT_ESCAPE;
476 cb->format_flags = GRAPHITE_STORE_RATES;
477
478 /* FIXME: Legacy configuration syntax. */
479 if (strcasecmp("Carbon", ci->key) != 0) {
480 status = cf_util_get_string(ci, &cb->name);
481 if (status != 0) {
482 wg_callback_free(cb);
483 return status;
484 }
485 }
486
487 pthread_mutex_init(&cb->send_lock, /* attr = */ NULL);
488 C_COMPLAIN_INIT(&cb->init_complaint);
489
490 for (int i = 0; i < ci->children_num; i++) {
491 oconfig_item_t *child = ci->children + i;
492
493 if (strcasecmp("Host", child->key) == 0)
494 cf_util_get_string(child, &cb->node);
495 else if (strcasecmp("Port", child->key) == 0)
496 cf_util_get_service(child, &cb->service);
497 else if (strcasecmp("Protocol", child->key) == 0) {
498 cf_util_get_string(child, &cb->protocol);
499
500 if (strcasecmp("UDP", cb->protocol) != 0 &&
501 strcasecmp("TCP", cb->protocol) != 0) {
502 ERROR("write_graphite plugin: Unknown protocol (%s)", cb->protocol);
503 status = -1;
504 }
505 } else if (strcasecmp("ReconnectInterval", child->key) == 0)
506 cf_util_get_cdtime(child, &cb->reconnect_interval);
507 else if (strcasecmp("LogSendErrors", child->key) == 0)
508 cf_util_get_boolean(child, &cb->log_send_errors);
509 else if (strcasecmp("Prefix", child->key) == 0)
510 cf_util_get_string(child, &cb->prefix);
511 else if (strcasecmp("Postfix", child->key) == 0)
512 cf_util_get_string(child, &cb->postfix);
513 else if (strcasecmp("StoreRates", child->key) == 0)
514 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_STORE_RATES);
515 else if (strcasecmp("SeparateInstances", child->key) == 0)
516 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_SEPARATE_INSTANCES);
517 else if (strcasecmp("AlwaysAppendDS", child->key) == 0)
518 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_ALWAYS_APPEND_DS);
519 else if (strcasecmp("PreserveSeparator", child->key) == 0)
520 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_PRESERVE_SEPARATOR);
521 else if (strcasecmp("DropDuplicateFields", child->key) == 0)
522 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_DROP_DUPE_FIELDS);
523 else if (strcasecmp("UseTags", child->key) == 0)
524 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_USE_TAGS);
525 else if (strcasecmp("ReverseHost", child->key) == 0)
526 cf_util_get_flag(child, &cb->format_flags, GRAPHITE_REVERSE_HOST);
527 else if (strcasecmp("EscapeCharacter", child->key) == 0)
528 config_set_char(&cb->escape_char, child);
529 else {
530 ERROR("write_graphite plugin: Invalid configuration "
531 "option: %s.",
532 child->key);
533 status = -1;
534 }
535
536 if (status != 0)
537 break;
538 }
539
540 if (status != 0) {
541 wg_callback_free(cb);
542 return status;
543 }
544
545 /* FIXME: Legacy configuration syntax. */
546 if (cb->name == NULL)
547 snprintf(callback_name, sizeof(callback_name), "write_graphite/%s/%s/%s",
548 cb->node, cb->service, cb->protocol);
549 else
550 snprintf(callback_name, sizeof(callback_name), "write_graphite/%s",
551 cb->name);
552
553 plugin_register_write(callback_name, wg_write,
554 &(user_data_t){
555 .data = cb,
556 .free_func = wg_callback_free,
557 });
558
559 plugin_register_flush(callback_name, wg_flush, &(user_data_t){.data = cb});
560
561 return 0;
562 }
563
564 static int wg_config(oconfig_item_t *ci) {
565 for (int i = 0; i < ci->children_num; i++) {
566 oconfig_item_t *child = ci->children + i;
567
568 if (strcasecmp("Node", child->key) == 0)
569 wg_config_node(child);
570 /* FIXME: Remove this legacy mode in version 6. */
571 else if (strcasecmp("Carbon", child->key) == 0)
572 wg_config_node(child);
573 else {
574 ERROR("write_graphite plugin: Invalid configuration "
575 "option: %s.",
576 child->key);
577 }
578 }
579
580 return 0;
581 }
582
583 void module_register(void) {
584 plugin_register_complex_config("write_graphite", wg_config);
585 }