static void
log_rewrite_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options, gpointer user_data)
{
LogRewrite *self = (LogRewrite *) s;
gchar buf[128];
gssize length;
const gchar *value;
if (self->condition && !filter_expr_eval_root(self->condition, &msg, path_options))
{
msg_debug("Rewrite condition unmatched, skipping rewrite",
evt_tag_str("value", log_msg_get_value_name(self->value_handle, NULL)),
NULL);
}
else
{
self->process(self, &msg, path_options);
}
if (G_UNLIKELY(debug_flag))
{
value = log_msg_get_value(msg, self->value_handle, &length);
msg_debug("Rewrite expression evaluation result",
evt_tag_str("value", log_msg_get_value_name(self->value_handle, NULL)),
evt_tag_printf("new_value", "%.*s", (gint) length, value),
evt_tag_str("rule", self->name),
evt_tag_str("location", log_expr_node_format_location(s->expr_node, buf, sizeof(buf))),
NULL);
}
log_pipe_forward_msg(s, msg, path_options);
}
static void
log_rewrite_rule_call_item(gpointer item, gpointer user_data)
{
LogRewrite *r = (LogRewrite *) item;
LogMessage *msg = (LogMessage *) user_data;
gssize length;
const gchar *value;
if (r->condition && !filter_expr_eval(r->condition, msg))
{
msg_debug("Rewrite condition unmatched, skipping rewrite",
evt_tag_str("value", log_msg_get_value_name(r->value_handle, NULL)),
NULL);
return;
}
r->process(r, msg);
if (G_UNLIKELY(debug_flag))
{
value = log_msg_get_value(msg, r->value_handle, &length);
msg_debug("Rewrite expression evaluation result",
evt_tag_str("value", log_msg_get_value_name(r->value_handle, NULL)),
evt_tag_printf("new_value", "%.*s", (gint) length, value),
NULL);
}
}
void
assert_log_message_value(LogMessage *self, NVHandle handle, const gchar *expected_value)
{
gssize key_name_length;
const gchar *key_name = log_msg_get_value_name(handle, &key_name_length);
const gchar *actual_value = log_msg_get_value(self, handle, NULL);
assert_string(actual_value, expected_value, "Value is not expected for key %s", key_name);
}
void
assert_log_message_values_equal(LogMessage *log_message_a, LogMessage *log_message_b, NVHandle handle)
{
gssize key_name_length;
const gchar *key_name = log_msg_get_value_name(handle, &key_name_length);
const gchar *value_a = log_msg_get_value(log_message_a, handle, NULL);
const gchar *value_b = log_msg_get_value(log_message_b, handle, NULL);
assert_string(value_a, value_b, "Value is not expected for key %s", key_name);
}
void
assert_log_message_value(LogMessage *self, NVHandle handle, const gchar *expected_value)
{
gssize key_name_length;
gssize value_length;
const gchar *key_name = log_msg_get_value_name(handle, &key_name_length);
const gchar *actual_value = log_msg_get_value(self, handle, &value_length);
if (expected_value)
assert_string(actual_value, expected_value, "Value is not expected for key %s", key_name);
else
assert_string(actual_value, "", "No value is expected for key %s but its value is %s", key_name, actual_value);
}
void
r_insert_node(RNode *root, guint8 *key, gpointer value, RNodeGetValueFunc value_func)
{
RNode *node;
gint keylen = strlen(key);
gint nodelen = root->keylen;
gint i = 0;
if (key[0] == '@')
{
guint8 *end;
if (keylen >= 2 && key[1] == '@')
{
/* we found and escape, so check if we already have a child with '@', or add a child like that */
node = r_find_child_by_first_character(root, key[1]);
if (!node)
{
/* no child so we create one
* if we are at the end of the key than use value, otherwise it is just a gap node
*/
node = r_new_node("@", (keylen == 2 ? value : NULL));
r_add_child(root, node);
}
else if (keylen == 2)
{
/* if we are at the end of the key set the value if it is not already exists,
* otherwise it is duplicate node
*/
if (!node->value)
node->value = value;
else
msg_error("Duplicate key in parser radix tree",
evt_tag_str("key", "@"),
evt_tag_str("value", value_func ? value_func(value) : "unknown"),
NULL);
}
/* go down building the tree if there is key left */
if (keylen > 2)
r_insert_node(node, key + 2, value, value_func);
}
else if ((keylen >= 2) && (end = strchr((const gchar *)key + 1, '@')) != NULL)
{
/* we are a parser node */
*end = '\0';
RParserNode *parser_node = r_new_pnode(key + 1);
if (parser_node)
{
node = r_find_pchild(root, parser_node);
if (!node)
{
node = r_new_node(NULL, NULL);
node->parser = parser_node;
r_add_pchild(root, node);
}
else
{
r_free_pnode_only(parser_node);
}
if ((end - key) < (keylen - 1))
{
/* the key is not over so go on building the tree */
r_insert_node(node, end + 1, value, value_func);
}
else
{
/* the key is over so set value if it is not yet set */
if (!node->value)
{
node->value = value;
}
else
{
/* FIXME: print parser type in string format */
msg_error("Duplicate parser node in radix tree",
evt_tag_int("type", node->parser->type),
evt_tag_str("name", log_msg_get_value_name(node->parser->handle, NULL)),
evt_tag_str("value", value_func ? value_func(value) : "unknown"),
NULL);
}
}
}
}
else
msg_error("Key contains '@' without escaping",
evt_tag_str("key", key),
evt_tag_str("value", value_func ? value_func(value) : "unknown"),
NULL);
}
else
{
/* we are not starting with @ sign or we are not interested in @ at all */
while (i < keylen && i < nodelen)
{
/* check if key is the same, or if it is a parser */
if ((key[i] != root->key[i]) || (key[i] == '@'))
break;
i++;
}
if (nodelen == 0 || i == 0 || (i < keylen && i >= nodelen))
{
/*either at the root or we need to go down the tree on the right child */
node = r_find_child_by_first_character(root, key[i]);
if (node)
{
/* @ is always a singel node, and we also have an @ so insert us under root */
if (key[i] == '@')
r_insert_node(root, key + i, value, value_func);
else
r_insert_node(node, key + i, value, value_func);
}
else
{
r_add_child_check(root, key + i, value, value_func);
}
}
else if (i == keylen && i == nodelen)
{
/* exact match */
if (!root->value)
root->value = value;
else
msg_error("Duplicate key in radix tree",
evt_tag_str("key", key),
evt_tag_str("value", value_func ? value_func(value) : "unknown"),
NULL);
}
else if (i > 0 && i < nodelen)
{
RNode *old_tree;
guint8 *new_key;
/* we need to split the current node */
old_tree = r_new_node(root->key + i, root->value);
if (root->num_children)
{
old_tree->children = root->children;
old_tree->num_children = root->num_children;
root->children = NULL;
root->num_children = 0;
}
if (root->num_pchildren)
{
old_tree->pchildren = root->pchildren;
old_tree->num_pchildren = root->num_pchildren;
root->pchildren = NULL;
root->num_pchildren = 0;
}
root->value = NULL;
new_key = g_strndup(root->key, i);
g_free(root->key);
root->key = new_key;
root->keylen = i;
r_add_child(root, old_tree);
if (i < keylen)
{
/* we add a new sub tree */
r_add_child_check(root, key + i, value, value_func);
}
else
{
/* the split is us */
root->value = value;
}
}
else
{
/* simply a new children */
r_add_child_check(root, key + i, value, value_func);
}
}
}
