static int
riemann_send(struct riemann_host *host, Msg const *msg)
{
u_char *buffer;
size_t buffer_len;
int status;
pthread_mutex_lock (&host->lock);
status = riemann_connect (host);
if (status != 0)
{
pthread_mutex_unlock (&host->lock);
return status;
}
buffer_len = msg__get_packed_size(msg);
if (host->use_tcp)
buffer_len += 4;
buffer = malloc (buffer_len);
if (buffer == NULL) {
pthread_mutex_unlock (&host->lock);
ERROR ("write_riemann plugin: malloc failed.");
return ENOMEM;
}
memset (buffer, 0, buffer_len);
if (host->use_tcp)
{
uint32_t length = htonl ((uint32_t) (buffer_len - 4));
memcpy (buffer, &length, 4);
msg__pack(msg, buffer + 4);
}
else
{
msg__pack(msg, buffer);
}
status = (int) swrite (host->s, buffer, buffer_len);
if (status != 0)
{
char errbuf[1024];
riemann_disconnect (host);
pthread_mutex_unlock (&host->lock);
ERROR ("write_riemann plugin: Sending to Riemann at %s:%s failed: %s",
(host->node != NULL) ? host->node : RIEMANN_HOST,
(host->service != NULL) ? host->service : RIEMANN_PORT,
sstrerror (errno, errbuf, sizeof (errbuf)));
sfree (buffer);
return -1;
}
pthread_mutex_unlock (&host->lock);
sfree (buffer);
return 0;
}
uint8_t *riemann_message_to_buffer(riemann_message_t *msg, size_t *len)
{
uint8_t *buf;
*len = msg__get_packed_size(msg);
buf = malloc(*len);
assert(buf);
msg__pack(msg, buf);
return buf;
}
int
send_message_to_riemann (Msg *message)
{
apr_time_t start = apr_time_now(), now;
debug_msg("[riemann] send_message_to_riemann()");
if (riemann_circuit_breaker == RIEMANN_CB_CLOSED) {
uint32_t len;
ssize_t nbytes;
struct {
uint32_t header;
uint8_t data[0];
} *buf;
int errsv;
if (!message)
return EXIT_FAILURE;
len = msg__get_packed_size (message) + sizeof (buf->header);
buf = malloc (len);
msg__pack (message, buf->data);
buf->header = htonl (len - sizeof (buf->header));
pthread_mutex_lock( &riemann_socket_mutex );
if ((nbytes = send (riemann_tcp_socket->sockfd, buf, len, 0)) == -1)
errsv = errno;
pthread_mutex_unlock( &riemann_socket_mutex );
free (buf);
if (nbytes == -1) {
err_msg("[riemann] TCP connection error: %s", strerror (errsv));
pthread_mutex_lock( &riemann_cb_mutex );
riemann_failures++;
pthread_mutex_unlock( &riemann_cb_mutex );
return EXIT_FAILURE;
} else if (nbytes != len) {
err_msg("[riemann] TCP connection error: failed to send all bytes");
pthread_mutex_lock( &riemann_cb_mutex );
riemann_failures++;
pthread_mutex_unlock( &riemann_cb_mutex );
return EXIT_FAILURE;
} else {
debug_msg("[riemann] Sent %lu events as 1 message in %lu serialized bytes", (unsigned long)message->n_events, (unsigned long)len);
}
}
ganglia_scoreboard_incby(METS_SENT_RIEMANN, message->n_events);
ganglia_scoreboard_incby(METS_SENT_ALL, message->n_events);
now = apr_time_now();
ganglia_scoreboard_incby(METS_ALL_DURATION, now - start);
ganglia_scoreboard_incby(METS_RIEMANN_DURATION, now - start);
last_riemann = now; //Updating global variable
return EXIT_SUCCESS;
}
uint8_t *riemann_message_to_tcp_buffer(riemann_message_t *msg, size_t *len)
{
uint8_t *buf;
uint32_t header;
*len = msg__get_packed_size(msg);
header = htobe32(*len); /* header */
buf = malloc(*len + sizeof(header));
assert(buf);
memcpy(buf, &header, sizeof(header));
msg__pack(msg, buf + sizeof(header));
*len += sizeof(header);
return buf;
}
int
send_event_to_riemann (Event *event)
{
apr_time_t start = apr_time_now(), now;
size_t len, nbytes;
void *buf;
int errsv;
Msg *riemann_msg = malloc (sizeof (Msg));
msg__init (riemann_msg);
riemann_msg->events = malloc(sizeof (Event));
riemann_msg->n_events = 1;
riemann_msg->events[0] = event;
len = msg__get_packed_size(riemann_msg);
buf = malloc(len);
msg__pack(riemann_msg, buf);
pthread_mutex_lock( &riemann_socket_mutex );
if ((nbytes = sendto (riemann_udp_socket->sockfd, buf, len, 0,
(struct sockaddr_in*)&riemann_udp_socket->sa, sizeof (struct sockaddr_in))) == -1)
errsv = errno;
pthread_mutex_unlock( &riemann_socket_mutex );
free (buf);
destroy_riemann_msg(riemann_msg);
if (nbytes == -1) {
err_msg ("[riemann] UDP connection error: %s", strerror (errsv));
return EXIT_FAILURE;
} else if (nbytes != len) {
err_msg ("[riemann] UDP connection error: failed to send all bytes");
return EXIT_FAILURE;
} else {
debug_msg ("[riemann] Sent 1 event in %lu serialized bytes", (unsigned long)len);
}
ganglia_scoreboard_inc(METS_SENT_RIEMANN);
ganglia_scoreboard_inc(METS_SENT_ALL);
now = apr_time_now();
ganglia_scoreboard_incby(METS_ALL_DURATION, now - start);
ganglia_scoreboard_incby(METS_RIEMANN_DURATION, now - start);
last_riemann = now; //Updating global variable
return EXIT_SUCCESS;
}
