static int meta_data_keys_to_json(char *buffer, size_t buffer_size, /* {{{ */
meta_data_t *meta, char **keys,
size_t keys_num) {
size_t offset = 0;
int status;
buffer[0] = 0;
#define BUFFER_ADD(...) \
do { \
status = ssnprintf(buffer + offset, buffer_size - offset, __VA_ARGS__); \
if (status < 1) \
return (-1); \
else if (((size_t)status) >= (buffer_size - offset)) \
return (-ENOMEM); \
else \
offset += ((size_t)status); \
} while (0)
for (size_t i = 0; i < keys_num; ++i) {
int type;
char *key = keys[i];
type = meta_data_type(meta, key);
if (type == MD_TYPE_STRING) {
char *value = NULL;
if (meta_data_get_string(meta, key, &value) == 0) {
char temp[512] = "";
status = json_escape_string(temp, sizeof(temp), value);
sfree(value);
if (status != 0)
return status;
BUFFER_ADD(",\"%s\":%s", key, temp);
}
} else if (type == MD_TYPE_SIGNED_INT) {
int64_t value = 0;
if (meta_data_get_signed_int(meta, key, &value) == 0)
BUFFER_ADD(",\"%s\":%" PRIi64, key, value);
} else if (type == MD_TYPE_UNSIGNED_INT) {
uint64_t value = 0;
if (meta_data_get_unsigned_int(meta, key, &value) == 0)
BUFFER_ADD(",\"%s\":%" PRIu64, key, value);
} else if (type == MD_TYPE_DOUBLE) {
double value = 0.0;
if (meta_data_get_double(meta, key, &value) == 0)
BUFFER_ADD(",\"%s\":%f", key, value);
} else if (type == MD_TYPE_BOOLEAN) {
_Bool value = 0;
if (meta_data_get_boolean(meta, key, &value) == 0)
BUFFER_ADD(",\"%s\":%s", key, value ? "true" : "false");
}
} /* for (keys) */
if (offset == 0)
return (ENOENT);
buffer[0] = '{'; /* replace leading ',' */
BUFFER_ADD("}");
#undef BUFFER_ADD
return (0);
} /* }}} int meta_data_keys_to_json */
static int tr_meta_data_action_invoke(/* {{{ */
tr_meta_data_action_t *act_head,
meta_data_t **dest) {
int status;
regmatch_t matches[8] = {[0] = {0}};
if (act_head == NULL)
return (-EINVAL);
if ((*dest) == NULL) /* nothing to do */
return (0);
for (tr_meta_data_action_t *act = act_head; act != NULL; act = act->next) {
char temp[DATA_MAX_NAME_LEN];
char *subst_status;
int value_type;
int meta_data_status;
char *value;
meta_data_t *result;
value_type = meta_data_type(*dest, act->key);
if (value_type == 0) /* not found */
continue;
if (value_type != MD_TYPE_STRING) {
WARNING("Target `replace': Attempting replace on metadata key `%s', "
"which isn't a string.",
act->key);
continue;
}
meta_data_status = meta_data_get_string(*dest, act->key, &value);
if (meta_data_status != 0) {
ERROR("Target `replace': Unable to retrieve metadata value for `%s'.",
act->key);
return (meta_data_status);
}
DEBUG("target_replace plugin: tr_meta_data_action_invoke: `%s' "
"old value = `%s'",
act->key, value);
status = regexec(&act->re, value, STATIC_ARRAY_SIZE(matches), matches,
/* flags = */ 0);
if (status == REG_NOMATCH) {
sfree(value);
continue;
} else if (status != 0) {
char errbuf[1024] = "";
regerror(status, &act->re, errbuf, sizeof(errbuf));
ERROR("Target `replace': Executing a regular expression failed: %s.",
errbuf);
sfree(value);
continue;
}
if (act->replacement == NULL) {
/* no replacement; delete the key */
DEBUG("target_replace plugin: tr_meta_data_action_invoke: "
"deleting `%s'",
act->key);
meta_data_delete(*dest, act->key);
sfree(value);
continue;
}
subst_status = subst(temp, sizeof(temp), value, (size_t)matches[0].rm_so,
(size_t)matches[0].rm_eo, act->replacement);
if (subst_status == NULL) {
ERROR("Target `replace': subst (value = %s, start = %zu, end = %zu, "
"replacement = %s) failed.",
value, (size_t)matches[0].rm_so, (size_t)matches[0].rm_eo,
act->replacement);
sfree(value);
continue;
}
DEBUG("target_replace plugin: tr_meta_data_action_invoke: `%s' "
"value `%s' -> `%s'",
act->key, value, temp);
if ((result = meta_data_create()) == NULL) {
ERROR("Target `replace': failed to create metadata for `%s'.", act->key);
sfree(value);
return (-ENOMEM);
}
meta_data_status = meta_data_add_string(result, act->key, temp);
if (meta_data_status != 0) {
ERROR("Target `replace': Unable to set metadata value for `%s'.",
act->key);
meta_data_destroy(result);
sfree(value);
return (meta_data_status);
}
meta_data_clone_merge(dest, result);
meta_data_destroy(result);
sfree(value);
} /* for (act = act_head; act != NULL; act = act->next) */
return (0);
} /* }}} int tr_meta_data_action_invoke */
static int gr_format_name (char *ret, int ret_len,
value_list_t const *vl,
char const *ds_name,
char const *prefix,
char const *postfix,
char const escape_char,
unsigned int flags)
{
char n_host[DATA_MAX_NAME_LEN];
char n_plugin[DATA_MAX_NAME_LEN];
char n_plugin_instance[DATA_MAX_NAME_LEN];
char n_type[DATA_MAX_NAME_LEN];
char n_type_instance[DATA_MAX_NAME_LEN];
char tmp_plugin[2 * DATA_MAX_NAME_LEN + 1];
char tmp_type[2 * DATA_MAX_NAME_LEN + 1];
if (prefix == NULL)
prefix = "";
if (postfix == NULL)
postfix = "";
gr_copy_escape_part (n_host, vl->host,
sizeof (n_host), escape_char);
gr_copy_escape_part (n_plugin, vl->plugin,
sizeof (n_plugin), escape_char);
gr_copy_escape_part (n_plugin_instance, vl->plugin_instance,
sizeof (n_plugin_instance), escape_char);
gr_copy_escape_part (n_type, vl->type,
sizeof (n_type), escape_char);
gr_copy_escape_part (n_type_instance, vl->type_instance,
sizeof (n_type_instance), escape_char);
if (n_plugin_instance[0] != '\0')
ssnprintf (tmp_plugin, sizeof (tmp_plugin), "%s%c%s",
n_plugin,
(flags & GRAPHITE_SEPARATE_INSTANCES) ? '.' : '-',
n_plugin_instance);
else
sstrncpy (tmp_plugin, n_plugin, sizeof (tmp_plugin));
if (n_type_instance[0] != '\0')
ssnprintf (tmp_type, sizeof (tmp_type), "%s%c%s",
n_type,
(flags & GRAPHITE_SEPARATE_INSTANCES) ? '.' : '-',
n_type_instance);
else
sstrncpy (tmp_type, n_type, sizeof (tmp_type));
char *username = NULL;
if (meta_data_get_string (vl->meta, "network:username", &username) != 0) {
WARNING ("No username provided with this packet? Can't write to graphite correctly");
}
/* Assert always_append_ds -> ds_name */
assert (!(flags & GRAPHITE_ALWAYS_APPEND_DS) || (ds_name != NULL));
if (ds_name != NULL)
ssnprintf (ret, ret_len, "%s%s.%s%s.%s.%s.%s",
prefix, username, n_host, postfix, tmp_plugin, tmp_type, ds_name);
else
ssnprintf (ret, ret_len, "%s%s.%s%s.%s.%s",
prefix, username, n_host, postfix, tmp_plugin, tmp_type);
if (username != NULL) {
sfree(username);
}
return (0);
}
