processes plugin: Implement the "CollectDelayAccounting" option.
[collectd.git] / src / write_riemann.c
1 /**
2  * collectd - src/write_riemann.c
3  * Copyright (C) 2012,2013  Pierre-Yves Ritschard
4  * Copyright (C) 2013       Florian octo Forster
5  * Copyright (C) 2015,2016  Gergely Nagy
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23  * DEALINGS IN THE SOFTWARE.
24  *
25  * Authors:
26  *   Pierre-Yves Ritschard <pyr at spootnik.org>
27  *   Florian octo Forster <octo at collectd.org>
28  *   Gergely Nagy <algernon at madhouse-project.org>
29  */
30
31 #include "collectd.h"
32
33 #include "common.h"
34 #include "plugin.h"
35 #include "utils_cache.h"
36 #include "utils_complain.h"
37 #include "write_riemann_threshold.h"
38
39 #include <riemann/riemann-client.h>
40
41 #define RIEMANN_HOST "localhost"
42 #define RIEMANN_PORT 5555
43 #define RIEMANN_TTL_FACTOR 2.0
44 #define RIEMANN_BATCH_MAX 8192
45
46 struct riemann_host {
47   c_complain_t init_complaint;
48   char *name;
49   char *event_service_prefix;
50   pthread_mutex_t lock;
51   _Bool batch_mode;
52   _Bool notifications;
53   _Bool check_thresholds;
54   _Bool store_rates;
55   _Bool always_append_ds;
56   char *node;
57   int port;
58   riemann_client_type_t client_type;
59   riemann_client_t *client;
60   double ttl_factor;
61   cdtime_t batch_init;
62   int batch_max;
63   int batch_timeout;
64   int reference_count;
65   riemann_message_t *batch_msg;
66   char *tls_ca_file;
67   char *tls_cert_file;
68   char *tls_key_file;
69   struct timeval timeout;
70 };
71
72 static char **riemann_tags;
73 static size_t riemann_tags_num;
74 static char **riemann_attrs;
75 static size_t riemann_attrs_num;
76
77 /* host->lock must be held when calling this function. */
78 static int wrr_connect(struct riemann_host *host) /* {{{ */
79 {
80   char const *node;
81   int port;
82
83   if (host->client)
84     return 0;
85
86   node = (host->node != NULL) ? host->node : RIEMANN_HOST;
87   port = (host->port) ? host->port : RIEMANN_PORT;
88
89   host->client = NULL;
90
91   host->client = riemann_client_create(
92       host->client_type, node, port, RIEMANN_CLIENT_OPTION_TLS_CA_FILE,
93       host->tls_ca_file, RIEMANN_CLIENT_OPTION_TLS_CERT_FILE,
94       host->tls_cert_file, RIEMANN_CLIENT_OPTION_TLS_KEY_FILE,
95       host->tls_key_file, RIEMANN_CLIENT_OPTION_NONE);
96   if (host->client == NULL) {
97     c_complain(LOG_ERR, &host->init_complaint,
98                "write_riemann plugin: Unable to connect to Riemann at %s:%d",
99                node, port);
100     return -1;
101   }
102 #if RCC_VERSION_NUMBER >= 0x010800
103   if (host->timeout.tv_sec != 0) {
104     if (riemann_client_set_timeout(host->client, &host->timeout) != 0) {
105       riemann_client_free(host->client);
106       host->client = NULL;
107       c_complain(LOG_ERR, &host->init_complaint,
108                  "write_riemann plugin: Unable to connect to Riemann at %s:%d",
109                  node, port);
110       return -1;
111     }
112   }
113 #endif
114
115   set_sock_opts(riemann_client_get_fd(host->client));
116
117   c_release(LOG_INFO, &host->init_complaint,
118             "write_riemann plugin: Successfully connected to %s:%d", node,
119             port);
120
121   return 0;
122 } /* }}} int wrr_connect */
123
124 /* host->lock must be held when calling this function. */
125 static int wrr_disconnect(struct riemann_host *host) /* {{{ */
126 {
127   if (!host->client)
128     return 0;
129
130   riemann_client_free(host->client);
131   host->client = NULL;
132
133   return 0;
134 } /* }}} int wrr_disconnect */
135
136 /**
137  * Function to send messages to riemann.
138  *
139  * Acquires the host lock, disconnects on errors.
140  */
141 static int wrr_send_nolock(struct riemann_host *host,
142                            riemann_message_t *msg) /* {{{ */
143 {
144   int status = 0;
145
146   status = wrr_connect(host);
147   if (status != 0) {
148     return status;
149   }
150
151   status = riemann_client_send_message(host->client, msg);
152   if (status != 0) {
153     wrr_disconnect(host);
154     return status;
155   }
156
157   /*
158    * For TCP we need to receive message acknowledgemenent.
159    */
160   if (host->client_type != RIEMANN_CLIENT_UDP) {
161     riemann_message_t *response;
162
163     response = riemann_client_recv_message(host->client);
164
165     if (response == NULL) {
166       wrr_disconnect(host);
167       return errno;
168     }
169     riemann_message_free(response);
170   }
171
172   return 0;
173 } /* }}} int wrr_send */
174
175 static int wrr_send(struct riemann_host *host, riemann_message_t *msg) {
176   int status = 0;
177
178   pthread_mutex_lock(&host->lock);
179   status = wrr_send_nolock(host, msg);
180   pthread_mutex_unlock(&host->lock);
181   return status;
182 }
183
184 static riemann_message_t *
185 wrr_notification_to_message(struct riemann_host *host, /* {{{ */
186                             notification_t const *n) {
187   riemann_message_t *msg;
188   riemann_event_t *event;
189   char service_buffer[6 * DATA_MAX_NAME_LEN];
190   char const *severity;
191
192   switch (n->severity) {
193   case NOTIF_OKAY:
194     severity = "ok";
195     break;
196   case NOTIF_WARNING:
197     severity = "warning";
198     break;
199   case NOTIF_FAILURE:
200     severity = "critical";
201     break;
202   default:
203     severity = "unknown";
204   }
205
206   format_name(service_buffer, sizeof(service_buffer),
207               /* host = */ "", n->plugin, n->plugin_instance, n->type,
208               n->type_instance);
209
210   event = riemann_event_create(
211       RIEMANN_EVENT_FIELD_HOST, n->host, RIEMANN_EVENT_FIELD_TIME,
212       (int64_t)CDTIME_T_TO_TIME_T(n->time), RIEMANN_EVENT_FIELD_TAGS,
213       "notification", NULL, RIEMANN_EVENT_FIELD_STATE, severity,
214       RIEMANN_EVENT_FIELD_SERVICE, &service_buffer[1],
215       RIEMANN_EVENT_FIELD_NONE);
216
217 #if RCC_VERSION_NUMBER >= 0x010A00
218   riemann_event_set(event, RIEMANN_EVENT_FIELD_TIME_MICROS,
219                     (int64_t)CDTIME_T_TO_US(n->time));
220 #endif
221
222   if (n->host[0] != 0)
223     riemann_event_string_attribute_add(event, "host", n->host);
224   if (n->plugin[0] != 0)
225     riemann_event_string_attribute_add(event, "plugin", n->plugin);
226   if (n->plugin_instance[0] != 0)
227     riemann_event_string_attribute_add(event, "plugin_instance",
228                                        n->plugin_instance);
229
230   if (n->type[0] != 0)
231     riemann_event_string_attribute_add(event, "type", n->type);
232   if (n->type_instance[0] != 0)
233     riemann_event_string_attribute_add(event, "type_instance",
234                                        n->type_instance);
235
236   for (size_t i = 0; i < riemann_attrs_num; i += 2)
237     riemann_event_string_attribute_add(event, riemann_attrs[i],
238                                        riemann_attrs[i + 1]);
239
240   for (size_t i = 0; i < riemann_tags_num; i++)
241     riemann_event_tag_add(event, riemann_tags[i]);
242
243   if (n->message[0] != 0)
244     riemann_event_string_attribute_add(event, "description", n->message);
245
246   /* Pull in values from threshold and add extra attributes */
247   for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next) {
248     if (strcasecmp("CurrentValue", meta->name) == 0 &&
249         meta->type == NM_TYPE_DOUBLE) {
250       riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D,
251                         (double)meta->nm_value.nm_double,
252                         RIEMANN_EVENT_FIELD_NONE);
253       continue;
254     }
255
256     if (meta->type == NM_TYPE_STRING) {
257       riemann_event_string_attribute_add(event, meta->name,
258                                          meta->nm_value.nm_string);
259       continue;
260     }
261   }
262
263   msg = riemann_message_create_with_events(event, NULL);
264   if (msg == NULL) {
265     ERROR("write_riemann plugin: riemann_message_create_with_events() failed.");
266     riemann_event_free(event);
267     return NULL;
268   }
269
270   DEBUG("write_riemann plugin: Successfully created message for notification: "
271         "host = \"%s\", service = \"%s\", state = \"%s\"",
272         event->host, event->service, event->state);
273   return msg;
274 } /* }}} riemann_message_t *wrr_notification_to_message */
275
276 static riemann_event_t *
277 wrr_value_to_event(struct riemann_host const *host, /* {{{ */
278                    data_set_t const *ds, value_list_t const *vl, size_t index,
279                    gauge_t const *rates, int status) {
280   riemann_event_t *event;
281   char name_buffer[5 * DATA_MAX_NAME_LEN];
282   char service_buffer[6 * DATA_MAX_NAME_LEN];
283   size_t i;
284
285   event = riemann_event_new();
286   if (event == NULL) {
287     ERROR("write_riemann plugin: riemann_event_new() failed.");
288     return NULL;
289   }
290
291   format_name(name_buffer, sizeof(name_buffer),
292               /* host = */ "", vl->plugin, vl->plugin_instance, vl->type,
293               vl->type_instance);
294   if (host->always_append_ds || (ds->ds_num > 1)) {
295     if (host->event_service_prefix == NULL)
296       snprintf(service_buffer, sizeof(service_buffer), "%s/%s", &name_buffer[1],
297                ds->ds[index].name);
298     else
299       snprintf(service_buffer, sizeof(service_buffer), "%s%s/%s",
300                host->event_service_prefix, &name_buffer[1], ds->ds[index].name);
301   } else {
302     if (host->event_service_prefix == NULL)
303       sstrncpy(service_buffer, &name_buffer[1], sizeof(service_buffer));
304     else
305       snprintf(service_buffer, sizeof(service_buffer), "%s%s",
306                host->event_service_prefix, &name_buffer[1]);
307   }
308
309   riemann_event_set(
310       event, RIEMANN_EVENT_FIELD_HOST, vl->host, RIEMANN_EVENT_FIELD_TIME,
311       (int64_t)CDTIME_T_TO_TIME_T(vl->time), RIEMANN_EVENT_FIELD_TTL,
312       (float)CDTIME_T_TO_DOUBLE(vl->interval) * host->ttl_factor,
313       RIEMANN_EVENT_FIELD_STRING_ATTRIBUTES, "plugin", vl->plugin, "type",
314       vl->type, "ds_name", ds->ds[index].name, NULL,
315       RIEMANN_EVENT_FIELD_SERVICE, service_buffer, RIEMANN_EVENT_FIELD_NONE);
316
317 #if RCC_VERSION_NUMBER >= 0x010A00
318   riemann_event_set(event, RIEMANN_EVENT_FIELD_TIME_MICROS,
319                     (int64_t)CDTIME_T_TO_US(vl->time));
320 #endif
321
322   if (host->check_thresholds) {
323     const char *state = NULL;
324
325     switch (status) {
326     case STATE_OKAY:
327       state = "ok";
328       break;
329     case STATE_ERROR:
330       state = "critical";
331       break;
332     case STATE_WARNING:
333       state = "warning";
334       break;
335     case STATE_MISSING:
336       state = "unknown";
337       break;
338     }
339     if (state)
340       riemann_event_set(event, RIEMANN_EVENT_FIELD_STATE, state,
341                         RIEMANN_EVENT_FIELD_NONE);
342   }
343
344   if (vl->plugin_instance[0] != 0)
345     riemann_event_string_attribute_add(event, "plugin_instance",
346                                        vl->plugin_instance);
347   if (vl->type_instance[0] != 0)
348     riemann_event_string_attribute_add(event, "type_instance",
349                                        vl->type_instance);
350
351   if ((ds->ds[index].type != DS_TYPE_GAUGE) && (rates != NULL)) {
352     char ds_type[DATA_MAX_NAME_LEN];
353
354     snprintf(ds_type, sizeof(ds_type), "%s:rate",
355              DS_TYPE_TO_STRING(ds->ds[index].type));
356     riemann_event_string_attribute_add(event, "ds_type", ds_type);
357   } else {
358     riemann_event_string_attribute_add(event, "ds_type",
359                                        DS_TYPE_TO_STRING(ds->ds[index].type));
360   }
361
362   {
363     char ds_index[DATA_MAX_NAME_LEN];
364
365     snprintf(ds_index, sizeof(ds_index), "%zu", index);
366     riemann_event_string_attribute_add(event, "ds_index", ds_index);
367   }
368
369   for (i = 0; i < riemann_attrs_num; i += 2)
370     riemann_event_string_attribute_add(event, riemann_attrs[i],
371                                        riemann_attrs[i + 1]);
372
373   for (i = 0; i < riemann_tags_num; i++)
374     riemann_event_tag_add(event, riemann_tags[i]);
375
376   if (ds->ds[index].type == DS_TYPE_GAUGE) {
377     riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D,
378                       (double)vl->values[index].gauge,
379                       RIEMANN_EVENT_FIELD_NONE);
380   } else if (rates != NULL) {
381     riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D, (double)rates[index],
382                       RIEMANN_EVENT_FIELD_NONE);
383   } else {
384     int64_t metric;
385
386     if (ds->ds[index].type == DS_TYPE_DERIVE)
387       metric = (int64_t)vl->values[index].derive;
388     else if (ds->ds[index].type == DS_TYPE_ABSOLUTE)
389       metric = (int64_t)vl->values[index].absolute;
390     else
391       metric = (int64_t)vl->values[index].counter;
392
393     riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_S64, (int64_t)metric,
394                       RIEMANN_EVENT_FIELD_NONE);
395   }
396
397   DEBUG("write_riemann plugin: Successfully created message for metric: "
398         "host = \"%s\", service = \"%s\"",
399         event->host, event->service);
400   return event;
401 } /* }}} riemann_event_t *wrr_value_to_event */
402
403 static riemann_message_t *
404 wrr_value_list_to_message(struct riemann_host const *host, /* {{{ */
405                           data_set_t const *ds, value_list_t const *vl,
406                           int *statuses) {
407   riemann_message_t *msg;
408   size_t i;
409   gauge_t *rates = NULL;
410
411   /* Initialize the Msg structure. */
412   msg = riemann_message_new();
413   if (msg == NULL) {
414     ERROR("write_riemann plugin: riemann_message_new failed.");
415     return NULL;
416   }
417
418   if (host->store_rates) {
419     rates = uc_get_rate(ds, vl);
420     if (rates == NULL) {
421       ERROR("write_riemann plugin: uc_get_rate failed.");
422       riemann_message_free(msg);
423       return NULL;
424     }
425   }
426
427   for (i = 0; i < vl->values_len; i++) {
428     riemann_event_t *event;
429
430     event = wrr_value_to_event(host, ds, vl, (int)i, rates, statuses[i]);
431     if (event == NULL) {
432       riemann_message_free(msg);
433       sfree(rates);
434       return NULL;
435     }
436     riemann_message_append_events(msg, event, NULL);
437   }
438
439   sfree(rates);
440   return msg;
441 } /* }}} riemann_message_t *wrr_value_list_to_message */
442
443 /*
444  * Always call while holding host->lock !
445  */
446 static int wrr_batch_flush_nolock(cdtime_t timeout, struct riemann_host *host) {
447   cdtime_t now;
448   int status = 0;
449
450   now = cdtime();
451   if (timeout > 0) {
452     if ((host->batch_init + timeout) > now) {
453       return status;
454     }
455   }
456   wrr_send_nolock(host, host->batch_msg);
457   riemann_message_free(host->batch_msg);
458
459   host->batch_init = now;
460   host->batch_msg = NULL;
461   return status;
462 }
463
464 static int wrr_batch_flush(cdtime_t timeout,
465                            const char *identifier __attribute__((unused)),
466                            user_data_t *user_data) {
467   struct riemann_host *host;
468   int status;
469
470   if (user_data == NULL)
471     return -EINVAL;
472
473   host = user_data->data;
474   pthread_mutex_lock(&host->lock);
475   status = wrr_batch_flush_nolock(timeout, host);
476   if (status != 0)
477     c_complain(
478         LOG_ERR, &host->init_complaint,
479         "write_riemann plugin: riemann_client_send failed with status %i",
480         status);
481   else
482     c_release(LOG_DEBUG, &host->init_complaint,
483               "write_riemann plugin: batch sent.");
484
485   pthread_mutex_unlock(&host->lock);
486   return status;
487 }
488
489 static int wrr_batch_add_value_list(struct riemann_host *host, /* {{{ */
490                                     data_set_t const *ds,
491                                     value_list_t const *vl, int *statuses) {
492   riemann_message_t *msg;
493   size_t len;
494   int ret;
495   cdtime_t timeout;
496
497   msg = wrr_value_list_to_message(host, ds, vl, statuses);
498   if (msg == NULL)
499     return -1;
500
501   pthread_mutex_lock(&host->lock);
502
503   if (host->batch_msg == NULL) {
504     host->batch_msg = msg;
505   } else {
506     int status;
507
508     status = riemann_message_append_events_n(host->batch_msg, msg->n_events,
509                                              msg->events);
510     msg->n_events = 0;
511     msg->events = NULL;
512
513     riemann_message_free(msg);
514
515     if (status != 0) {
516       pthread_mutex_unlock(&host->lock);
517       ERROR("write_riemann plugin: out of memory");
518       return -1;
519     }
520   }
521
522   len = riemann_message_get_packed_size(host->batch_msg);
523   ret = 0;
524   if ((host->batch_max < 0) || (((size_t)host->batch_max) <= len)) {
525     ret = wrr_batch_flush_nolock(0, host);
526   } else {
527     if (host->batch_timeout > 0) {
528       timeout = TIME_T_TO_CDTIME_T((time_t)host->batch_timeout);
529       ret = wrr_batch_flush_nolock(timeout, host);
530     }
531   }
532
533   pthread_mutex_unlock(&host->lock);
534   return ret;
535 } /* }}} riemann_message_t *wrr_batch_add_value_list */
536
537 static int wrr_notification(const notification_t *n, user_data_t *ud) /* {{{ */
538 {
539   int status;
540   struct riemann_host *host = ud->data;
541   riemann_message_t *msg;
542
543   if (!host->notifications)
544     return 0;
545
546   /*
547    * Never batch for notifications, send them ASAP
548    */
549   msg = wrr_notification_to_message(host, n);
550   if (msg == NULL)
551     return -1;
552
553   status = wrr_send(host, msg);
554   if (status != 0)
555     c_complain(
556         LOG_ERR, &host->init_complaint,
557         "write_riemann plugin: riemann_client_send failed with status %i",
558         status);
559   else
560     c_release(LOG_DEBUG, &host->init_complaint,
561               "write_riemann plugin: riemann_client_send succeeded");
562
563   riemann_message_free(msg);
564   return status;
565 } /* }}} int wrr_notification */
566
567 static int wrr_write(const data_set_t *ds, /* {{{ */
568                      const value_list_t *vl, user_data_t *ud) {
569   int status = 0;
570   int statuses[vl->values_len];
571   struct riemann_host *host = ud->data;
572   riemann_message_t *msg;
573
574   if (host->check_thresholds) {
575     status = write_riemann_threshold_check(ds, vl, statuses);
576     if (status != 0)
577       return status;
578   } else {
579     memset(statuses, 0, sizeof(statuses));
580   }
581
582   if (host->client_type != RIEMANN_CLIENT_UDP && host->batch_mode) {
583     wrr_batch_add_value_list(host, ds, vl, statuses);
584   } else {
585     msg = wrr_value_list_to_message(host, ds, vl, statuses);
586     if (msg == NULL)
587       return -1;
588
589     status = wrr_send(host, msg);
590
591     riemann_message_free(msg);
592   }
593   return status;
594 } /* }}} int wrr_write */
595
596 static void wrr_free(void *p) /* {{{ */
597 {
598   struct riemann_host *host = p;
599
600   if (host == NULL)
601     return;
602
603   pthread_mutex_lock(&host->lock);
604
605   host->reference_count--;
606   if (host->reference_count > 0) {
607     pthread_mutex_unlock(&host->lock);
608     return;
609   }
610
611   wrr_disconnect(host);
612
613   pthread_mutex_lock(&host->lock);
614   pthread_mutex_destroy(&host->lock);
615   sfree(host);
616 } /* }}} void wrr_free */
617
618 static int wrr_config_node(oconfig_item_t *ci) /* {{{ */
619 {
620   struct riemann_host *host = NULL;
621   int status = 0;
622   int i;
623   oconfig_item_t *child;
624   char callback_name[DATA_MAX_NAME_LEN];
625
626   if ((host = calloc(1, sizeof(*host))) == NULL) {
627     ERROR("write_riemann plugin: calloc failed.");
628     return ENOMEM;
629   }
630   pthread_mutex_init(&host->lock, NULL);
631   C_COMPLAIN_INIT(&host->init_complaint);
632   host->reference_count = 1;
633   host->node = NULL;
634   host->port = 0;
635   host->notifications = 1;
636   host->check_thresholds = 0;
637   host->store_rates = 1;
638   host->always_append_ds = 0;
639   host->batch_mode = 1;
640   host->batch_max = RIEMANN_BATCH_MAX; /* typical MSS */
641   host->batch_init = cdtime();
642   host->batch_timeout = 0;
643   host->ttl_factor = RIEMANN_TTL_FACTOR;
644   host->client = NULL;
645   host->client_type = RIEMANN_CLIENT_TCP;
646   host->timeout.tv_sec = 0;
647   host->timeout.tv_usec = 0;
648
649   status = cf_util_get_string(ci, &host->name);
650   if (status != 0) {
651     WARNING("write_riemann plugin: Required host name is missing.");
652     wrr_free(host);
653     return -1;
654   }
655
656   for (i = 0; i < ci->children_num; i++) {
657     /*
658      * The code here could be simplified but makes room
659      * for easy adding of new options later on.
660      */
661     child = &ci->children[i];
662     status = 0;
663
664     if (strcasecmp("Host", child->key) == 0) {
665       status = cf_util_get_string(child, &host->node);
666       if (status != 0)
667         break;
668     } else if (strcasecmp("Notifications", child->key) == 0) {
669       status = cf_util_get_boolean(child, &host->notifications);
670       if (status != 0)
671         break;
672     } else if (strcasecmp("EventServicePrefix", child->key) == 0) {
673       status = cf_util_get_string(child, &host->event_service_prefix);
674       if (status != 0)
675         break;
676     } else if (strcasecmp("CheckThresholds", child->key) == 0) {
677       status = cf_util_get_boolean(child, &host->check_thresholds);
678       if (status != 0)
679         break;
680     } else if (strcasecmp("Batch", child->key) == 0) {
681       status = cf_util_get_boolean(child, &host->batch_mode);
682       if (status != 0)
683         break;
684     } else if (strcasecmp("BatchMaxSize", child->key) == 0) {
685       status = cf_util_get_int(child, &host->batch_max);
686       if (status != 0)
687         break;
688     } else if (strcasecmp("BatchFlushTimeout", child->key) == 0) {
689       status = cf_util_get_int(child, &host->batch_timeout);
690       if (status != 0)
691         break;
692     } else if (strcasecmp("Timeout", child->key) == 0) {
693 #if RCC_VERSION_NUMBER >= 0x010800
694       status = cf_util_get_int(child, (int *)&host->timeout.tv_sec);
695       if (status != 0)
696         break;
697 #else
698       WARNING("write_riemann plugin: The Timeout option is not supported. "
699               "Please upgrade the Riemann client to at least 1.8.0.");
700 #endif
701     } else if (strcasecmp("Port", child->key) == 0) {
702       host->port = cf_util_get_port_number(child);
703       if (host->port == -1) {
704         ERROR("write_riemann plugin: Invalid argument "
705               "configured for the \"Port\" "
706               "option.");
707         break;
708       }
709     } else if (strcasecmp("Protocol", child->key) == 0) {
710       char tmp[16];
711       status = cf_util_get_string_buffer(child, tmp, sizeof(tmp));
712       if (status != 0) {
713         ERROR("write_riemann plugin: cf_util_get_"
714               "string_buffer failed with "
715               "status %i.",
716               status);
717         break;
718       }
719
720       if (strcasecmp("UDP", tmp) == 0)
721         host->client_type = RIEMANN_CLIENT_UDP;
722       else if (strcasecmp("TCP", tmp) == 0)
723         host->client_type = RIEMANN_CLIENT_TCP;
724       else if (strcasecmp("TLS", tmp) == 0)
725         host->client_type = RIEMANN_CLIENT_TLS;
726       else
727         WARNING("write_riemann plugin: The value "
728                 "\"%s\" is not valid for the "
729                 "\"Protocol\" option. Use "
730                 "either \"UDP\", \"TCP\" or \"TLS\".",
731                 tmp);
732     } else if (strcasecmp("TLSCAFile", child->key) == 0) {
733       status = cf_util_get_string(child, &host->tls_ca_file);
734       if (status != 0) {
735         ERROR("write_riemann plugin: cf_util_get_"
736               "string_buffer failed with "
737               "status %i.",
738               status);
739         break;
740       }
741     } else if (strcasecmp("TLSCertFile", child->key) == 0) {
742       status = cf_util_get_string(child, &host->tls_cert_file);
743       if (status != 0) {
744         ERROR("write_riemann plugin: cf_util_get_"
745               "string_buffer failed with "
746               "status %i.",
747               status);
748         break;
749       }
750     } else if (strcasecmp("TLSKeyFile", child->key) == 0) {
751       status = cf_util_get_string(child, &host->tls_key_file);
752       if (status != 0) {
753         ERROR("write_riemann plugin: cf_util_get_"
754               "string_buffer failed with "
755               "status %i.",
756               status);
757         break;
758       }
759     } else if (strcasecmp("StoreRates", child->key) == 0) {
760       status = cf_util_get_boolean(child, &host->store_rates);
761       if (status != 0)
762         break;
763     } else if (strcasecmp("AlwaysAppendDS", child->key) == 0) {
764       status = cf_util_get_boolean(child, &host->always_append_ds);
765       if (status != 0)
766         break;
767     } else if (strcasecmp("TTLFactor", child->key) == 0) {
768       double tmp = NAN;
769       status = cf_util_get_double(child, &tmp);
770       if (status != 0)
771         break;
772       if (tmp >= 2.0) {
773         host->ttl_factor = tmp;
774       } else if (tmp >= 1.0) {
775         NOTICE("write_riemann plugin: The configured "
776                "TTLFactor is very small "
777                "(%.1f). A value of 2.0 or "
778                "greater is recommended.",
779                tmp);
780         host->ttl_factor = tmp;
781       } else if (tmp > 0.0) {
782         WARNING("write_riemann plugin: The configured "
783                 "TTLFactor is too small to be "
784                 "useful (%.1f). I'll use it "
785                 "since the user knows best, "
786                 "but under protest.",
787                 tmp);
788         host->ttl_factor = tmp;
789       } else { /* zero, negative and NAN */
790         ERROR("write_riemann plugin: The configured "
791               "TTLFactor is invalid (%.1f).",
792               tmp);
793       }
794     } else {
795       WARNING("write_riemann plugin: ignoring unknown config "
796               "option: \"%s\"",
797               child->key);
798     }
799   }
800   if (status != 0) {
801     wrr_free(host);
802     return status;
803   }
804
805   snprintf(callback_name, sizeof(callback_name), "write_riemann/%s",
806            host->name);
807
808   user_data_t ud = {.data = host, .free_func = wrr_free};
809
810   pthread_mutex_lock(&host->lock);
811
812   status = plugin_register_write(callback_name, wrr_write, &ud);
813
814   if (host->client_type != RIEMANN_CLIENT_UDP && host->batch_mode) {
815     ud.free_func = NULL;
816     plugin_register_flush(callback_name, wrr_batch_flush, &ud);
817   }
818   if (status != 0)
819     WARNING("write_riemann plugin: plugin_register_write (\"%s\") "
820             "failed with status %i.",
821             callback_name, status);
822   else /* success */
823     host->reference_count++;
824
825   status = plugin_register_notification(callback_name, wrr_notification, &ud);
826   if (status != 0)
827     WARNING("write_riemann plugin: plugin_register_notification (\"%s\") "
828             "failed with status %i.",
829             callback_name, status);
830   else /* success */
831     host->reference_count++;
832
833   if (host->reference_count <= 1) {
834     /* Both callbacks failed => free memory.
835      * We need to unlock here, because riemann_free() will lock.
836      * This is not a race condition, because we're the only one
837      * holding a reference. */
838     pthread_mutex_unlock(&host->lock);
839     wrr_free(host);
840     return -1;
841   }
842
843   host->reference_count--;
844   pthread_mutex_unlock(&host->lock);
845
846   return status;
847 } /* }}} int wrr_config_node */
848
849 static int wrr_config(oconfig_item_t *ci) /* {{{ */
850 {
851   int i;
852   oconfig_item_t *child;
853   int status;
854
855   for (i = 0; i < ci->children_num; i++) {
856     child = &ci->children[i];
857
858     if (strcasecmp("Node", child->key) == 0) {
859       wrr_config_node(child);
860     } else if (strcasecmp(child->key, "attribute") == 0) {
861       char *key = NULL;
862       char *val = NULL;
863
864       if (child->values_num != 2) {
865         WARNING("riemann attributes need both a key and a value.");
866         return -1;
867       }
868       if (child->values[0].type != OCONFIG_TYPE_STRING ||
869           child->values[1].type != OCONFIG_TYPE_STRING) {
870         WARNING("riemann attribute needs string arguments.");
871         return -1;
872       }
873       if ((key = strdup(child->values[0].value.string)) == NULL) {
874         WARNING("cannot allocate memory for attribute key.");
875         return -1;
876       }
877       if ((val = strdup(child->values[1].value.string)) == NULL) {
878         WARNING("cannot allocate memory for attribute value.");
879         sfree(key);
880         return -1;
881       }
882       strarray_add(&riemann_attrs, &riemann_attrs_num, key);
883       strarray_add(&riemann_attrs, &riemann_attrs_num, val);
884       DEBUG("write_riemann: got attr: %s => %s", key, val);
885       sfree(key);
886       sfree(val);
887     } else if (strcasecmp(child->key, "tag") == 0) {
888       char *tmp = NULL;
889       status = cf_util_get_string(child, &tmp);
890       if (status != 0)
891         continue;
892
893       strarray_add(&riemann_tags, &riemann_tags_num, tmp);
894       DEBUG("write_riemann plugin: Got tag: %s", tmp);
895       sfree(tmp);
896     } else {
897       WARNING("write_riemann plugin: Ignoring unknown "
898               "configuration option \"%s\" at top level.",
899               child->key);
900     }
901   }
902   return 0;
903 } /* }}} int wrr_config */
904
905 void module_register(void) {
906   plugin_register_complex_config("write_riemann", wrr_config);
907 }