END_TEST
START_TEST (test_riemann_event_clone)
{
riemann_event_t *event, *clone;
ck_assert (riemann_event_clone (NULL) == NULL);
ck_assert_errno (-errno, EINVAL);
event = riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test",
RIEMANN_EVENT_FIELD_TIME, (int64_t) 1234,
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_DESCRIPTION, "something",
RIEMANN_EVENT_FIELD_TAGS, "tag-1", "tag-2", NULL,
RIEMANN_EVENT_FIELD_TTL, (float) 1,
RIEMANN_EVENT_FIELD_ATTRIBUTES,
riemann_attribute_create ("key-1", "value-1"),
riemann_attribute_create ("key-2", "value-2"),
NULL,
RIEMANN_EVENT_FIELD_METRIC_S64, (int64_t) 12345,
RIEMANN_EVENT_FIELD_NONE);
clone = riemann_event_clone (event);
ck_assert (clone != NULL);
ck_assert (clone != event);
ck_assert (clone->host != event->host);
ck_assert_str_eq (clone->host, event->host);
ck_assert (clone->service != event->service);
ck_assert_str_eq (clone->service, event->service);
ck_assert_int_eq (clone->time, event->time);
ck_assert (clone->state != event->state);
ck_assert_str_eq (clone->state, event->state);
ck_assert (clone->description != event->description);
ck_assert_str_eq (clone->description, event->description);
ck_assert_int_eq (clone->metric_sint64, event->metric_sint64);
ck_assert (clone->tags != NULL);
ck_assert_int_eq (clone->n_tags, event->n_tags);
ck_assert (clone->tags[0] != event->tags[0]);
ck_assert_str_eq (clone->tags[0], event->tags[0]);
ck_assert (clone->attributes != NULL);
ck_assert_int_eq (clone->n_attributes, event->n_attributes);
ck_assert (clone->attributes[0] != event->attributes[0]);
ck_assert_str_eq (clone->attributes[0]->key,
event->attributes[0]->key);
riemann_event_free (event);
riemann_event_free (clone);
}
END_TEST
START_TEST (test_riemann_event_create)
{
riemann_event_t *event;
event = riemann_event_create (RIEMANN_EVENT_EMPTY);
ck_assert (event != NULL);
riemann_event_free (event);
event = riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test",
RIEMANN_EVENT_FIELD_NONE);
ck_assert (event != NULL);
ck_assert_str_eq (event->host, "localhost");
ck_assert_str_eq (event->service, "test");
riemann_event_free (event);
event = riemann_event_create (255);
ck_assert (event == NULL);
ck_assert_errno (-errno, EPROTO);
}
END_TEST
START_TEST (test_riemann_simple_communicate)
{
riemann_client_t *client, *dummy_client;
riemann_message_t *message, *response;
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
ck_assert (riemann_communicate (NULL, NULL) == NULL);
ck_assert_errno (-errno, ENOTCONN);
ck_assert (riemann_communicate (client, NULL) == NULL);
ck_assert_errno (-errno, EINVAL);
ck_assert (riemann_communicate (NULL, message) == NULL);
ck_assert_errno (-errno, ENOTCONN);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
dummy_client = riemann_client_new ();
ck_assert (riemann_communicate (dummy_client, message) == NULL);
ck_assert_errno (-errno, ENOTCONN);
riemann_client_free (dummy_client);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
response = riemann_communicate
(client,
riemann_message_create_with_query
(riemann_query_new ("true")));
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate #2",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
riemann_message_set_query (message,
riemann_query_new ("true"));
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate #2",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
riemann_message_set_query (message,
riemann_query_new ("true"));
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events == 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_free (client);
}
static riemann_message_t *
wrr_notification_to_message(struct riemann_host *host, /* {{{ */
notification_t const *n) {
riemann_message_t *msg;
riemann_event_t *event;
char service_buffer[6 * DATA_MAX_NAME_LEN];
char const *severity;
switch (n->severity) {
case NOTIF_OKAY:
severity = "ok";
break;
case NOTIF_WARNING:
severity = "warning";
break;
case NOTIF_FAILURE:
severity = "critical";
break;
default:
severity = "unknown";
}
format_name(service_buffer, sizeof(service_buffer),
/* host = */ "", n->plugin, n->plugin_instance, n->type,
n->type_instance);
event = riemann_event_create(
RIEMANN_EVENT_FIELD_HOST, n->host, RIEMANN_EVENT_FIELD_TIME,
(int64_t)CDTIME_T_TO_TIME_T(n->time), RIEMANN_EVENT_FIELD_TAGS,
"notification", NULL, RIEMANN_EVENT_FIELD_STATE, severity,
RIEMANN_EVENT_FIELD_SERVICE, &service_buffer[1],
RIEMANN_EVENT_FIELD_NONE);
#if RCC_VERSION_NUMBER >= 0x010A00
riemann_event_set(event, RIEMANN_EVENT_FIELD_TIME_MICROS,
(int64_t)CDTIME_T_TO_US(n->time));
#endif
if (n->host[0] != 0)
riemann_event_string_attribute_add(event, "host", n->host);
if (n->plugin[0] != 0)
riemann_event_string_attribute_add(event, "plugin", n->plugin);
if (n->plugin_instance[0] != 0)
riemann_event_string_attribute_add(event, "plugin_instance",
n->plugin_instance);
if (n->type[0] != 0)
riemann_event_string_attribute_add(event, "type", n->type);
if (n->type_instance[0] != 0)
riemann_event_string_attribute_add(event, "type_instance",
n->type_instance);
for (size_t i = 0; i < riemann_attrs_num; i += 2)
riemann_event_string_attribute_add(event, riemann_attrs[i],
riemann_attrs[i + 1]);
for (size_t i = 0; i < riemann_tags_num; i++)
riemann_event_tag_add(event, riemann_tags[i]);
if (n->message[0] != 0)
riemann_event_string_attribute_add(event, "description", n->message);
/* Pull in values from threshold and add extra attributes */
for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next) {
if (strcasecmp("CurrentValue", meta->name) == 0 &&
meta->type == NM_TYPE_DOUBLE) {
riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D,
(double)meta->nm_value.nm_double,
RIEMANN_EVENT_FIELD_NONE);
continue;
}
if (meta->type == NM_TYPE_STRING) {
riemann_event_string_attribute_add(event, meta->name,
meta->nm_value.nm_string);
continue;
}
}
msg = riemann_message_create_with_events(event, NULL);
if (msg == NULL) {
ERROR("write_riemann plugin: riemann_message_create_with_events() failed.");
riemann_event_free(event);
return NULL;
}
DEBUG("write_riemann plugin: Successfully created message for notification: "
"host = \"%s\", service = \"%s\", state = \"%s\"",
event->host, event->service, event->state);
return msg;
} /* }}} riemann_message_t *wrr_notification_to_message */
int main(int argc, char** argv){
int r;
char* end;
sd_journal *j;
riemann_client_t *c;
riemann_message_t *req, *res;
riemann_event_t *event;
int after_wait = 0;
r = sd_journal_open(&j, 0);
assert(r == 0);
if(argc != 3 && argc != 6){
fprintf(stderr,"usage: journal2riemann <host> <port> [<ca-file> <cert-file> <key-file>]\n");
fprintf(stderr,"example: journal2riemann 127.0.0.1 5555\n");
exit(1);
}
long port = strtol(argv[2],&end,10);
if(argc >= 6){
c = riemann_client_create (
RIEMANN_CLIENT_TLS, argv[1], port,
RIEMANN_CLIENT_OPTION_TLS_CA_FILE, argv[3],
RIEMANN_CLIENT_OPTION_TLS_CERT_FILE, argv[4],
RIEMANN_CLIENT_OPTION_TLS_KEY_FILE, argv[5],
RIEMANN_CLIENT_OPTION_TLS_HANDSHAKE_TIMEOUT, 10000,
RIEMANN_CLIENT_OPTION_NONE);
}else{
c = riemann_client_create (RIEMANN_CLIENT_TCP, argv[1], port);
}
r = sd_journal_seek_tail(j);
assert(r == 0);
for (;;) {
const void *field; size_t len;
r = sd_journal_next(j); assert (r >= 0);
if (r == 0) { // if no more log available, wait for new ones
r = sd_journal_wait(j, (uint64_t) -1);
assert (r >= 0);
after_wait = 1;
continue;
}
else if (!after_wait){ // skip all logs before the first wait
continue;
}
event = riemann_event_create(RIEMANN_EVENT_FIELD_NONE);
strncpy(servicename,"journal",8);
SD_JOURNAL_FOREACH_DATA(j, field, len){
char* attr = ""; enum RiemannType type; void* val;
int matched = NOMATCH;
MATCH(F,RIEMANN_EVENT_FIELD_DESCRIPTION , STRING , "MESSAGE=")
MATCH(A,"message_id" , STRING , "MESSAGE_ID=")
MATCH(F,RIEMANN_EVENT_FIELD_STATE , STATE , "PRIORITY=")
MATCH(F,MATCHNOTHING , STRING , "CODE_FILE=")
MATCH(F,MATCHNOTHING , STRING , "CODE_LINE=")
MATCH(F,MATCHNOTHING , STRING , "CODE_FUNC=")
MATCH(F,MATCHNOTHING , STRING , "ERRNO=")
MATCH(F,MATCHNOTHING , STRING , "SYSLOG_FACILITY=")
MATCH(F,MATCHNOTHING , STRING , "SYSLOG_IDENTIFIER=")
MATCH(F,MATCHNOTHING , STRING , "SYSLOG_PID=")
MATCH(F,MATCHNOTHING , STRING , "_PID=")
MATCH(F,MATCHNOTHING , STRING , "_UID=")
MATCH(F,MATCHNOTHING , STRING , "_GID=")
MATCH(F,MATCHNOTHING , STRING , "_COMM=")
MATCH(F,MATCHNOTHING , STRING , "_EXE=")
MATCH(A,"command_line" , STRING , "_CMDLINE=")
MATCH(F,MATCHNOTHING , STRING , "_CAP_EFFECTIVE=")
MATCH(F,MATCHNOTHING , STRING , "_AUDIT_SESSION=")
MATCH(F,MATCHNOTHING , STRING , "_AUDIT_LOGINUID=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_CGROUP=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_SESSION=")
MATCH(F,SERVICEPART , STRING , "_SYSTEMD_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_USER_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_OWNER_UID=")
MATCH(F,MATCHNOTHING , STRING , "_SYSTEMD_SLICE=")
MATCH(F,MATCHNOTHING , STRING , "_SELINUX_CONTEXT=")
MATCH(F,RIEMANN_EVENT_FIELD_TIME , TIME , "_SOURCE_REALTIME_TIMESTAMP=")
MATCH(F,MATCHNOTHING , STRING , "_BOOT_ID=")
MATCH(F,MATCHNOTHING , STRING , "_MACHINE_ID=")
MATCH(F,RIEMANN_EVENT_FIELD_HOST , STRING , "_HOSTNAME=")
MATCH(F,MATCHNOTHING , STRING , "_TRANSPORT=")
MATCH(F,MATCHNOTHING , STRING , "_KERNEL_DEVICE=")
MATCH(F,MATCHNOTHING , STRING , "_KERNEL_SUBSYSTEM=")
MATCH(F,MATCHNOTHING , STRING , "_UDEV_SYSNAME=")
MATCH(F,MATCHNOTHING , STRING , "_UDEV_DEVNODE=")
MATCH(F,MATCHNOTHING , STRING , "_UDEV_DEVLINK=")
MATCH(F,MATCHNOTHING , STRING , "COREDUMP_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "COREDUMP_USER_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_UID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_GID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_COMM=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_EXE=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_CMDLINE=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_AUDIT_SESSION=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_AUDIT_LOGINUID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_CGROUP=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_SESSION=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_OWNER_UID=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "OBJECT_SYSTEMD_USER_UNIT=")
MATCH(F,MATCHNOTHING , STRING , "__CURSOR=")
MATCH(F,MATCHNOTHING , STRING , "__REALTIME_TIMESTAMP=")
MATCH(F,MATCHNOTHING , STRING , "__MONOTONIC_TIMESTAMP=")
if(matched != MATCHNOTHING && matched != NOMATCH){
memcpy(valuebuf,field,len); *(valuebuf+len) = 0;
switch(type){
case STATE:
val = (void*) states[atoi(valuebuf)];
break;
case TIME:
*(valuebuf+len-6) = 0;
long t = strtol(valuebuf,&end,10);
val = (int64_t) t;
break;
default:
val = (void*) valuebuf;
}
switch(matched){
case ATTRIBUTE:
riemann_event_string_attribute_add(event,attr,valuebuf); break;
case TAG:
riemann_event_tag_add(event,valuebuf); break;
case SERVICEPART:
if(len > 0){
strncat(servicename," ",2);
strncat(servicename,valuebuf,len+1);
}
break;
default:
riemann_event_set(event,matched,val,RIEMANN_EVENT_FIELD_NONE);
}
}
}
riemann_event_set(event,RIEMANN_EVENT_FIELD_SERVICE,servicename,RIEMANN_EVENT_FIELD_NONE);
req = riemann_message_create_with_events(event, NULL);
res = riemann_communicate(c, req);
if (!res)
{
fprintf (stderr, "Error communicating with Riemann: %s\n",
strerror (errno));
exit (1);
}
if (res->error)
{
fprintf (stderr, "Error communicating with Riemann: %s\n",
res->error);
exit (1);
}
if (res->has_ok && !res->ok)
{
fprintf (stderr, "Error communicating with Riemann: %s\n",
strerror (errno));
exit (1);
}
riemann_message_free(res);
}
