END_TEST
START_TEST (test_riemann_event_set_one)
{
riemann_event_t *event;
event = riemann_event_new ();
ck_assert (riemann_event_set_one (event, TIME, (int64_t) 1234) == 0);
ck_assert_int_eq (event->has_time, 1);
ck_assert_int_eq (event->time, 1234);
ck_assert (riemann_event_set_one (event, HOST, "localhost") == 0);
ck_assert_str_eq (event->host, "localhost");
ck_assert (riemann_event_set_one (event, TAGS, "tag-1", "tag-2", NULL) == 0);
ck_assert_str_eq (event->tags[0], "tag-1");
ck_assert_str_eq (event->tags[1], "tag-2");
ck_assert (riemann_event_set_one (event, HOST, "localhost2") == 0);
ck_assert_str_eq (event->host, "localhost2");
ck_assert (riemann_event_set_one (event, TAGS, "tag-3", NULL) == 0);
ck_assert_int_eq (event->n_tags, 1);
ck_assert_str_eq (event->tags[0], "tag-3");
riemann_event_free (event);
}
END_TEST
START_TEST (test_riemann_event_tag_add)
{
riemann_event_t *event;
event = riemann_event_new ();
ck_assert_errno (riemann_event_tag_add (NULL, NULL), EINVAL);
ck_assert_errno (riemann_event_tag_add (event, NULL), EINVAL);
ck_assert_errno (riemann_event_tag_add (event, "test-tag"), 0);
ck_assert_int_eq (event->n_tags, 1);
ck_assert_str_eq (event->tags[0], "test-tag");
riemann_event_free (event);
}
END_TEST
START_TEST (test_riemann_event_attribute_add)
{
riemann_event_t *event;
event = riemann_event_new ();
ck_assert_errno (riemann_event_attribute_add (NULL, NULL), EINVAL);
ck_assert_errno (riemann_event_attribute_add (event, NULL), EINVAL);
ck_assert_errno (riemann_event_attribute_add
(event, riemann_attribute_create ("test-key", "value")), 0);
ck_assert_int_eq (event->n_attributes, 1);
ck_assert_str_eq (event->attributes[0]->key, "test-key");
riemann_event_free (event);
}
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_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 */
