END_TEST START_TEST (test_riemann_event_set) { riemann_event_t *event; ck_assert_errno (riemann_event_set (NULL), EINVAL); event = riemann_event_new (); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_TIME, (int64_t) 1234, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert_int_eq (event->has_time, 1); ck_assert_int_eq (event->time, 1234); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_STATE, "ok", RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert (event->state != NULL); ck_assert_str_eq (event->state, "ok"); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_SERVICE, "test", RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert (event->service != NULL); ck_assert_str_eq (event->service, "test"); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_HOST, "localhost", RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert (event->host != NULL); ck_assert_str_eq (event->host, "localhost"); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_DESCRIPTION, "something", RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert (event->description != NULL); ck_assert_str_eq (event->description, "something"); ck_assert_errno (riemann_event_set (event, RIEMANN_EVENT_FIELD_TAGS, "tag-1", "tag-2", NULL, RIEMANN_EVENT_FIELD_NONE), 0); ck_assert_int_eq (event->n_tags, 2); ck_assert_str_eq (event->tags[0], "tag-1"); ck_assert_str_eq (event->tags[1], "tag-2"); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_TTL, (float) 1, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert_int_eq (event->has_ttl, 1); ck_assert_float_eq (event->ttl, (float) 1); ck_assert_errno (riemann_event_set (event, RIEMANN_EVENT_FIELD_ATTRIBUTES, riemann_attribute_create ("key-1", "value-1"), riemann_attribute_create ("key-2", "value-2"), NULL, RIEMANN_EVENT_FIELD_NONE), 0); ck_assert_int_eq (event->n_attributes, 2); ck_assert_str_eq (event->attributes[0]->key, "key-1"); ck_assert_str_eq (event->attributes[1]->value, "value-2"); ck_assert_errno (riemann_event_set (event, RIEMANN_EVENT_FIELD_ATTRIBUTES, riemann_attribute_create ("key-3", "value-3"), NULL, RIEMANN_EVENT_FIELD_NONE), 0); ck_assert_int_eq (event->n_attributes, 1); ck_assert_str_eq (event->attributes[0]->key, "key-3"); ck_assert_str_eq (event->attributes[0]->value, "value-3"); ck_assert_errno (riemann_event_set (event, RIEMANN_EVENT_FIELD_STRING_ATTRIBUTES, "key-4", "value-4", "key-5", "value-5", NULL, RIEMANN_EVENT_FIELD_NONE), 0); ck_assert_int_eq (event->n_attributes, 2); ck_assert_str_eq (event->attributes[0]->key, "key-4"); ck_assert_str_eq (event->attributes[1]->value, "value-5"); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_METRIC_S64, (int64_t) 12345, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert_int_eq (event->has_metric_sint64, 1); ck_assert_int_eq (event->metric_sint64, 12345); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_METRIC_D, (double) 1.5, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert_int_eq (event->has_metric_d, 1); ck_assert_float_eq (event->metric_d, 1.5); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_METRIC_F, (float) 1.5, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert_int_eq (event->has_metric_f, 1); ck_assert_float_eq (event->metric_f, 1.5); ck_assert_errno (riemann_event_set (event, RIEMANN_EVENT_FIELD_METRIC_F * 2, 0, RIEMANN_EVENT_FIELD_NONE), EPROTO); ck_assert (riemann_event_set (event, RIEMANN_EVENT_FIELD_SERVICE, NULL, RIEMANN_EVENT_FIELD_NONE) == 0); ck_assert (event->service == NULL); riemann_event_free (event); }
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 */
static riemann_event_t * wrr_value_to_event(struct riemann_host const *host, /* {{{ */ data_set_t const *ds, value_list_t const *vl, size_t index, gauge_t const *rates, int status) { riemann_event_t *event; char name_buffer[5 * DATA_MAX_NAME_LEN]; char service_buffer[6 * DATA_MAX_NAME_LEN]; size_t i; event = riemann_event_new(); if (event == NULL) { ERROR("write_riemann plugin: riemann_event_new() failed."); return NULL; } format_name(name_buffer, sizeof(name_buffer), /* host = */ "", vl->plugin, vl->plugin_instance, vl->type, vl->type_instance); if (host->always_append_ds || (ds->ds_num > 1)) { if (host->event_service_prefix == NULL) snprintf(service_buffer, sizeof(service_buffer), "%s/%s", &name_buffer[1], ds->ds[index].name); else snprintf(service_buffer, sizeof(service_buffer), "%s%s/%s", host->event_service_prefix, &name_buffer[1], ds->ds[index].name); } else { if (host->event_service_prefix == NULL) sstrncpy(service_buffer, &name_buffer[1], sizeof(service_buffer)); else snprintf(service_buffer, sizeof(service_buffer), "%s%s", host->event_service_prefix, &name_buffer[1]); } riemann_event_set( event, RIEMANN_EVENT_FIELD_HOST, vl->host, RIEMANN_EVENT_FIELD_TIME, (int64_t)CDTIME_T_TO_TIME_T(vl->time), RIEMANN_EVENT_FIELD_TTL, (float)CDTIME_T_TO_DOUBLE(vl->interval) * host->ttl_factor, RIEMANN_EVENT_FIELD_STRING_ATTRIBUTES, "plugin", vl->plugin, "type", vl->type, "ds_name", ds->ds[index].name, NULL, RIEMANN_EVENT_FIELD_SERVICE, service_buffer, RIEMANN_EVENT_FIELD_NONE); #if RCC_VERSION_NUMBER >= 0x010A00 riemann_event_set(event, RIEMANN_EVENT_FIELD_TIME_MICROS, (int64_t)CDTIME_T_TO_US(vl->time)); #endif if (host->check_thresholds) { const char *state = NULL; switch (status) { case STATE_OKAY: state = "ok"; break; case STATE_ERROR: state = "critical"; break; case STATE_WARNING: state = "warning"; break; case STATE_MISSING: state = "unknown"; break; } if (state) riemann_event_set(event, RIEMANN_EVENT_FIELD_STATE, state, RIEMANN_EVENT_FIELD_NONE); } if (vl->plugin_instance[0] != 0) riemann_event_string_attribute_add(event, "plugin_instance", vl->plugin_instance); if (vl->type_instance[0] != 0) riemann_event_string_attribute_add(event, "type_instance", vl->type_instance); if ((ds->ds[index].type != DS_TYPE_GAUGE) && (rates != NULL)) { char ds_type[DATA_MAX_NAME_LEN]; snprintf(ds_type, sizeof(ds_type), "%s:rate", DS_TYPE_TO_STRING(ds->ds[index].type)); riemann_event_string_attribute_add(event, "ds_type", ds_type); } else { riemann_event_string_attribute_add(event, "ds_type", DS_TYPE_TO_STRING(ds->ds[index].type)); } { char ds_index[DATA_MAX_NAME_LEN]; snprintf(ds_index, sizeof(ds_index), "%" PRIsz, index); riemann_event_string_attribute_add(event, "ds_index", ds_index); } for (i = 0; i < riemann_attrs_num; i += 2) riemann_event_string_attribute_add(event, riemann_attrs[i], riemann_attrs[i + 1]); for (i = 0; i < riemann_tags_num; i++) riemann_event_tag_add(event, riemann_tags[i]); if (ds->ds[index].type == DS_TYPE_GAUGE) { riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D, (double)vl->values[index].gauge, RIEMANN_EVENT_FIELD_NONE); } else if (rates != NULL) { riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_D, (double)rates[index], RIEMANN_EVENT_FIELD_NONE); } else { int64_t metric; if (ds->ds[index].type == DS_TYPE_DERIVE) metric = (int64_t)vl->values[index].derive; else if (ds->ds[index].type == DS_TYPE_ABSOLUTE) metric = (int64_t)vl->values[index].absolute; else metric = (int64_t)vl->values[index].counter; riemann_event_set(event, RIEMANN_EVENT_FIELD_METRIC_S64, (int64_t)metric, RIEMANN_EVENT_FIELD_NONE); } DEBUG("write_riemann plugin: Successfully created message for metric: " "host = \"%s\", service = \"%s\"", event->host, event->service); return event; } /* }}} riemann_event_t *wrr_value_to_event */
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); }