void
stats_reset_non_stored_counters(void)
{
stats_lock();
stats_foreach_counter(_reset_non_stored_counter, NULL);
stats_unlock();
}
gboolean
log_dest_driver_deinit_method(LogPipe *s)
{
LogDestDriver *self = (LogDestDriver *) s;
GList *l, *l_next;
for (l = self->queues; l; l = l_next)
{
LogQueue *q = (LogQueue *) l->data;
/* the GList struct will be freed by log_dest_driver_release_queue */
l_next = l->next;
/* we have to pass a reference to log_dest_driver_release_queue(),
* which automatically frees the ref on the list too */
log_dest_driver_release_queue(self, log_queue_ref(q));
}
g_assert(self->queues == NULL);
stats_lock();
stats_unregister_counter(SCS_DESTINATION | SCS_GROUP, self->super.group, NULL, SC_TYPE_PROCESSED, &self->super.processed_group_messages);
stats_unregister_counter(SCS_CENTER, NULL, "queued", SC_TYPE_PROCESSED, &self->queued_global_messages);
stats_unlock();
if (!log_driver_deinit_method(s))
return FALSE;
return TRUE;
}
void
test_stats()
{
GString *reply = NULL;
GString *command = g_string_sized_new(128);
StatsCounterItem *counter = NULL;
gchar **stats_result;
stats_init();
stats_lock();
stats_register_counter(0, SCS_CENTER, "id", "received", SC_TYPE_PROCESSED, &counter);
stats_unlock();
g_string_assign(command,"STATS");
reply = control_connection_send_stats(command);
stats_result = g_strsplit(reply->str, "\n", 2);
assert_string(stats_result[0], "SourceName;SourceId;SourceInstance;State;Type;Number",
"Bad reply");
g_strfreev(stats_result);
g_string_free(reply, TRUE);
g_string_free(command, TRUE);
stats_destroy();
return;
}
gboolean
log_threaded_dest_driver_deinit_method(LogPipe *s)
{
LogThrDestDriver *self = (LogThrDestDriver *)s;
log_queue_reset_parallel_push(self->queue);
log_queue_set_counters(self->queue, NULL, NULL);
cfg_persist_config_add(log_pipe_get_config(s),
log_threaded_dest_driver_format_seqnum_for_persist(self),
GINT_TO_POINTER(self->seq_num), NULL, FALSE);
stats_lock();
stats_unregister_counter(self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_unregister_counter(self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_unregister_counter(self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_PROCESSED, &self->processed_messages);
stats_unlock();
if (!log_dest_driver_deinit_method(s))
return FALSE;
return TRUE;
}
void
log_tags_global_deinit(void)
{
gint i;
g_static_mutex_lock(&log_tags_lock);
g_hash_table_destroy(log_tags_hash);
stats_lock();
StatsClusterKey sc_key;
for (i = 0; i < log_tags_num; i++)
{
stats_cluster_logpipe_key_set(&sc_key, SCS_TAG, log_tags_list[i].name, NULL );
stats_unregister_counter(&sc_key, SC_TYPE_PROCESSED, &log_tags_list[i].counter);
g_free(log_tags_list[i].name);
}
stats_unlock();
log_tags_num = 0;
g_free(log_tags_list);
log_tags_list = NULL;
log_tags_hash = NULL;
g_static_mutex_unlock(&log_tags_lock);
}
void
test_reset_stats()
{
GString *reply = NULL;
GString *command = g_string_sized_new(128);
StatsCounterItem *counter = NULL;
stats_init();
stats_lock();
stats_register_counter(0, SCS_CENTER, "id", "received", SC_TYPE_PROCESSED, &counter);
stats_counter_set(counter, 666);
stats_unlock();
g_string_assign(command, "RESET_STATS");
reply = control_connection_reset_stats(command);
assert_string(reply->str, "The statistics of syslog-ng have been reset to 0.", "Bad reply");
g_string_free(reply, TRUE);
g_string_assign(command, "STATS");
reply = control_connection_send_stats(command);
assert_string(reply->str, "SourceName;SourceId;SourceInstance;State;Type;Number\ncenter;id;received;a;processed;0\n", "Bad reply");
g_string_free(reply, TRUE);
stats_destroy();
g_string_free(command, TRUE);
return;
}
static void
_update_index(void)
{
g_static_mutex_lock(&stats_query_mutex);
stats_lock();
stats_foreach_cluster(_update_indexes_of_cluster_if_needed, NULL);
stats_unlock();
g_static_mutex_unlock(&stats_query_mutex);
}
gboolean
log_source_deinit(LogPipe *s)
{
LogSource *self = (LogSource *) s;
stats_lock();
stats_unregister_counter(self->stats_source | SCS_SOURCE, self->stats_id, self->stats_instance, SC_TYPE_PROCESSED, &self->recvd_messages);
stats_unregister_counter(self->stats_source | SCS_SOURCE, self->stats_id, self->stats_instance, SC_TYPE_STAMP, &self->last_message_seen);
stats_unlock();
return TRUE;
}
static gboolean
afmongodb_dd_init(LogPipe *s)
{
MongoDBDestDriver *self = (MongoDBDestDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
if (cfg)
self->time_reopen = cfg->time_reopen;
if (!self->vp)
{
self->vp = value_pairs_new();
value_pairs_add_scope(self->vp, "selected-macros");
value_pairs_add_scope(self->vp, "nv-pairs");
}
self->host = NULL;
self->port = 27017;
if (!mongo_util_parse_addr(g_list_nth_data(self->servers, 0), &self->host,
&self->port))
{
msg_error("Cannot parse the primary host",
evt_tag_str("primary", g_list_nth_data(self->servers, 0)),
NULL);
return FALSE;
}
msg_verbose("Initializing MongoDB destination",
evt_tag_str("host", self->host),
evt_tag_int("port", self->port),
evt_tag_str("database", self->db),
evt_tag_str("collection", self->coll),
NULL);
self->queue = log_dest_driver_acquire_queue(&self->super, afmongodb_dd_format_persist_name(self));
stats_lock();
stats_register_counter(0, SCS_MONGODB | SCS_DESTINATION, self->super.super.id,
afmongodb_dd_format_stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_register_counter(0, SCS_MONGODB | SCS_DESTINATION, self->super.super.id,
afmongodb_dd_format_stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_unlock();
log_queue_set_counters(self->queue, self->stored_messages, self->dropped_messages);
afmongodb_dd_start_thread(self);
return TRUE;
}
gchar *
stats_generate_csv(void)
{
GString *csv = g_string_sized_new(1024);
g_string_append_printf(csv, "%s;%s;%s;%s;%s;%s\n", "SourceName", "SourceId", "SourceInstance", "State", "Type",
"Number");
stats_lock();
stats_foreach_counter(stats_format_csv, csv);
stats_unlock();
return g_string_free(csv, FALSE);
}
/*
* log_tags_get_by_name
*
* Lookup a tag id by it's name. If the tag is seen for the first time
* the next tag id is assigned and the tag is added to the list.
*
* The function returns the tag id associated with the name.
*
* @name: the name of the tag
*
*/
LogTagId
log_tags_get_by_name(const gchar *name)
{
/* If log_tags_hash() is NULL, this unit is already deinitialized
but other thread may refer the tag structure.
If name is empty, it is an extremal element.
In both cases the return value is 0.
*/
guint id;
g_assert(log_tags_hash != NULL);
g_static_mutex_lock(&log_tags_lock);
id = GPOINTER_TO_UINT(g_hash_table_lookup(log_tags_hash, name)) - 1;
if (id == 0xffffffff)
{
if (log_tags_num < LOG_TAGS_MAX - 1)
{
id = log_tags_num++;
if (id == log_tags_list_size)
{
log_tags_list_size *= 2;
log_tags_list = g_renew(LogTag, log_tags_list, log_tags_list_size);
}
log_tags_list[id].id = id;
log_tags_list[id].name = g_strdup(name);
log_tags_list[id].counter = NULL;
/* NOTE: stats-level may not be set for calls that happen during
* config file parsing, those get fixed up by
* log_tags_reinit_stats() below */
stats_lock();
StatsClusterKey sc_key;
stats_cluster_logpipe_key_set(&sc_key, SCS_TAG, name, NULL );
stats_register_counter(3, &sc_key, SC_TYPE_PROCESSED, &log_tags_list[id].counter);
stats_unlock();
g_hash_table_insert(log_tags_hash, log_tags_list[id].name, GUINT_TO_POINTER(log_tags_list[id].id + 1));
}
else
id = 0;
}
g_static_mutex_unlock(&log_tags_lock);
return id;
}
gboolean
log_threaded_dest_driver_start(LogPipe *s)
{
LogThrDestDriver *self = (LogThrDestDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (cfg && self->time_reopen == -1)
self->time_reopen = cfg->time_reopen;
self->queue = log_dest_driver_acquire_queue(&self->super,
self->format.persist_name(self));
if (self->queue == NULL)
{
return FALSE;
}
if (self->retries.max <= 0)
{
msg_warning("Wrong value for retries(), setting to default",
evt_tag_int("value", self->retries.max),
evt_tag_int("default", MAX_RETRIES_OF_FAILED_INSERT_DEFAULT),
evt_tag_str("driver", self->super.super.id),
NULL);
self->retries.max = MAX_RETRIES_OF_FAILED_INSERT_DEFAULT;
}
stats_lock();
stats_register_counter(0, self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_register_counter(0, self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_register_counter(0, self->stats_source | SCS_DESTINATION, self->super.super.id,
self->format.stats_instance(self),
SC_TYPE_PROCESSED, &self->processed_messages);
stats_unlock();
log_queue_set_counters(self->queue, self->stored_messages,
self->dropped_messages);
self->seq_num = GPOINTER_TO_INT(cfg_persist_config_fetch(cfg, log_threaded_dest_driver_format_seqnum_for_persist(self)));
if (!self->seq_num)
init_sequence_number(&self->seq_num);
log_threaded_dest_driver_start_thread(self);
return TRUE;
}
gboolean
log_src_driver_deinit_method(LogPipe *s)
{
LogSrcDriver *self = (LogSrcDriver *) s;
if (!log_driver_deinit_method(s))
return FALSE;
stats_lock();
stats_unregister_counter(SCS_SOURCE | SCS_GROUP, self->super.group, NULL, SC_TYPE_PROCESSED, &self->super.processed_group_messages);
stats_unregister_counter(SCS_CENTER, NULL, "received", SC_TYPE_PROCESSED, &self->received_global_messages);
stats_unlock();
return TRUE;
}
void ICharacter::consumeHP (const uint32_t amount)
{
if (amount)
{
boost::mutex::scoped_lock stats_lock(m_stats_mutex);
if (m_HP)
{
if ( amount > m_HP)
m_HP = 0;
else
m_HP -= amount;
if (!m_HP)
{
stats_lock.unlock();
if (!signal_dead.empty())
signal_dead(m_UniqueID,m_CurrentPos);
boost::lock(m_state_mutex,m_queue_mutex,m_mov_mutex);
boost::unique_lock<boost::mutex> stateLock(m_state_mutex,boost::adopt_lock);
boost::unique_lock<boost::mutex> queueLock(m_queue_mutex,boost::adopt_lock);
boost::unique_lock<boost::mutex> moveLock(m_mov_mutex,boost::adopt_lock);
if (m_AttackState != ATTACK_ACTION_STOP)
{
m_AttackState = ATTACK_ACTION_STOP;
if (!signal_state.empty())
signal_state(STATE_ATTACK,m_AttackState);
}
m_StatusState = STATUS_ACTION_DEAD;
if (!signal_state.empty())
signal_state(STATE_STATUS,m_StatusState);
m_QueueSkill = 0;
m_QueueTarget = 0;
m_CurrentTask = 0;
m_NextPos = Coord();
}
}
}
}
static gboolean
afamqp_dd_init(LogPipe *s)
{
AMQPDestDriver *self = (AMQPDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
if (cfg)
self->time_reopen = cfg->time_reopen;
if (!self->vp)
{
self->vp = value_pairs_new();
value_pairs_add_scope(self->vp, "selected-macros");
value_pairs_add_scope(self->vp, "nv-pairs");
value_pairs_add_scope(self->vp, "sdata");
}
msg_verbose("Initializing AMQP destination",
evt_tag_str("vhost", self->vhost),
evt_tag_str("host", self->host),
evt_tag_int("port", self->port),
evt_tag_str("exchange", self->exchange),
evt_tag_str("exchange_type", self->exchange_type),
NULL);
self->queue = log_dest_driver_acquire_queue(&self->super, afamqp_dd_format_persist_name(self));
stats_lock();
stats_register_counter(0, SCS_AMQP | SCS_DESTINATION,
self->super.super.id, afamqp_dd_format_stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_register_counter(0, SCS_AMQP | SCS_DESTINATION,
self->super.super.id, afamqp_dd_format_stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_unlock();
log_queue_set_counters(self->queue, self->stored_messages,
self->dropped_messages);
afamqp_dd_start_thread(self);
return TRUE;
}
/*
* log_tags_get_by_name
*
* Lookup a tag id by it's name. If the tag is seen for the first time
* the next tag id is assigned and the tag is added to the list.
*
* The function returns the tag id associated with the name.
*
* @name: the name of the tag
*
*/
LogTagId
log_tags_get_by_name(const gchar *name)
{
/* If log_tags_hash() is NULL, this unit is already deinitialized
but other thread may refer the tag structure.
If name is empty, it is an extremal element.
In both cases the return value is 0.
*/
guint id;
g_assert(log_tags_hash != NULL);
g_static_mutex_lock(&log_tags_lock);
id = GPOINTER_TO_UINT(g_hash_table_lookup(log_tags_hash, name)) - 1;
if (id == 0xffffffff)
{
if (log_tags_num < LOG_TAGS_MAX - 1)
{
id = log_tags_num++;
if (id == log_tags_list_size)
{
log_tags_list_size *= 2;
log_tags_list = g_renew(LogTag, log_tags_list, log_tags_list_size);
}
log_tags_list[id].id = id;
log_tags_list[id].name = g_strdup(name);
log_tags_list[id].counter = NULL;
stats_lock();
stats_register_counter(3, SCS_TAG, name, NULL, SC_TYPE_PROCESSED, &log_tags_list[id].counter);
stats_unlock();
g_hash_table_insert(log_tags_hash, log_tags_list[id].name, GUINT_TO_POINTER(log_tags_list[id].id + 1));
}
else
id = 0;
}
g_static_mutex_unlock(&log_tags_lock);
return id;
}
static gboolean
afmongodb_dd_deinit(LogPipe *s)
{
MongoDBDestDriver *self = (MongoDBDestDriver *)s;
afmongodb_dd_stop_thread(self);
log_queue_set_counters(self->queue, NULL, NULL);
stats_lock();
stats_unregister_counter(SCS_MONGODB | SCS_DESTINATION, self->super.super.id,
afmongodb_dd_format_stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_unregister_counter(SCS_MONGODB | SCS_DESTINATION, self->super.super.id,
afmongodb_dd_format_stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_unlock();
if (!log_dest_driver_deinit_method(s))
return FALSE;
return TRUE;
}
/*
* NOTE: this is called at cfg_init() time to update the set of counters we
* have. If stats-level is decreased, we should unregister everything we
* had earlier. If increased we need to register them again.
*
* log_tags_get_by_name() will also try to register the counter for calls
* that are _after_ cfg_init(). Early calls to log_tags_get_by_name() will
* not see a proper stats-level() in the global variable here. Those will
* get handled by this function.
*/
void
log_tags_reinit_stats(void)
{
gint id;
stats_lock();
for (id = 0; id < log_tags_num; id++)
{
const gchar *name = log_tags_list[id].name;
StatsClusterKey sc_key;
stats_cluster_logpipe_key_set(&sc_key, SCS_TAG, name, NULL );
if (stats_check_level(3))
stats_register_counter(3, &sc_key, SC_TYPE_PROCESSED, &log_tags_list[id].counter);
else
stats_unregister_counter(&sc_key, SC_TYPE_PROCESSED, &log_tags_list[id].counter);
}
stats_unlock();
}
Test(logqueue, test_zero_diskbuf_and_normal_acks)
{
LogQueue *q;
gint i;
q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
StatsClusterKey sc_key;
stats_lock();
stats_cluster_logpipe_key_set(&sc_key, SCS_DESTINATION, q->persist_name, NULL );
stats_register_counter(0, &sc_key, SC_TYPE_QUEUED, &q->queued_messages);
stats_register_counter(1, &sc_key, SC_TYPE_MEMORY_USAGE, &q->memory_usage);
stats_unlock();
log_queue_set_use_backlog(q, TRUE);
cr_assert_eq(atomic_gssize_racy_get(&q->queued_messages->value), 0);
fed_messages = 0;
acked_messages = 0;
feed_some_messages(q, 1);
cr_assert_eq(stats_counter_get(q->queued_messages), 1);
cr_assert_neq(stats_counter_get(q->memory_usage), 0);
gint size_when_single_msg = stats_counter_get(q->memory_usage);
for (i = 0; i < 10; i++)
feed_some_messages(q, 10);
cr_assert_eq(stats_counter_get(q->queued_messages), 101);
cr_assert_eq(stats_counter_get(q->memory_usage), 101*size_when_single_msg);
send_some_messages(q, fed_messages);
log_queue_ack_backlog(q, fed_messages);
cr_assert_eq(fed_messages, acked_messages,
"did not receive enough acknowledgements: fed_messages=%d, acked_messages=%d",
fed_messages, acked_messages);
log_queue_unref(q);
}
Test(control_cmds, test_stats)
{
StatsCounterItem *counter = NULL;
gchar **stats_result;
const gchar *response;
stats_init();
stats_lock();
StatsClusterKey sc_key;
stats_cluster_logpipe_key_set(&sc_key, SCS_CENTER, "id", "received" );
stats_register_counter(0, &sc_key, SC_TYPE_PROCESSED, &counter);
stats_unlock();
_run_command("STATS", &response);
stats_result = g_strsplit(response, "\n", 2);
cr_assert_str_eq(stats_result[0], "SourceName;SourceId;SourceInstance;State;Type;Number",
"Bad reply");
g_strfreev(stats_result);
stats_destroy();
}
gboolean
log_dest_driver_init_method(LogPipe *s)
{
LogDestDriver *self = (LogDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_driver_init_method(s))
return FALSE;
if (!self->super.group)
{
self->super.group = cfg_tree_get_rule_name(&cfg->tree, ENC_DESTINATION, s->expr_node);
self->super.id = cfg_tree_get_child_id(&cfg->tree, ENC_DESTINATION, s->expr_node);
}
stats_lock();
stats_register_counter(0, SCS_DESTINATION | SCS_GROUP, self->super.group, NULL, SC_TYPE_PROCESSED, &self->super.processed_group_messages);
stats_register_counter(0, SCS_CENTER, NULL, "queued", SC_TYPE_PROCESSED, &self->queued_global_messages);
stats_unlock();
return TRUE;
}
gboolean
log_src_driver_init_method(LogPipe *s)
{
LogSrcDriver *self = (LogSrcDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_driver_init_method(s))
return FALSE;
if (!self->super.group)
{
self->super.group = cfg_tree_get_rule_name(&cfg->tree, ENC_SOURCE, s->expr_node);
self->group_len = strlen(self->super.group);
self->super.id = cfg_tree_get_child_id(&cfg->tree, ENC_SOURCE, s->expr_node);
}
stats_lock();
stats_register_counter(0, SCS_SOURCE | SCS_GROUP, self->super.group, NULL, SC_TYPE_PROCESSED, &self->super.processed_group_messages);
stats_register_counter(0, SCS_CENTER, NULL, "received", SC_TYPE_PROCESSED, &self->received_global_messages);
stats_unlock();
return TRUE;
}
Test(control_cmds, test_reset_stats)
{
StatsCounterItem *counter = NULL;
const gchar *response;
stats_init();
stats_lock();
StatsClusterKey sc_key;
stats_cluster_logpipe_key_set(&sc_key, SCS_CENTER, "id", "received" );
stats_register_counter(0, &sc_key, SC_TYPE_PROCESSED, &counter);
stats_counter_set(counter, 666);
stats_unlock();
_run_command("RESET_STATS", &response);
cr_assert(first_line_eq(response, "OK The statistics of syslog-ng have been reset to 0."), "Bad reply");
_run_command("STATS", &response);
cr_assert_str_eq(response,
"SourceName;SourceId;SourceInstance;State;Type;Number\ncenter;id;received;a;processed;0\n.\n",
"Bad reply");
stats_destroy();
}
void
log_tags_deinit(void)
{
gint i;
g_static_mutex_lock(&log_tags_lock);
g_hash_table_destroy(log_tags_hash);
stats_lock();
for (i = 0; i < log_tags_num; i++)
{
stats_unregister_counter(SCS_TAG, log_tags_list[i].name, NULL, SC_TYPE_PROCESSED, &log_tags_list[i].counter);
g_free(log_tags_list[i].name);
}
stats_unlock();
log_tags_num = 0;
g_free(log_tags_list);
log_tags_list = NULL;
log_tags_hash = NULL;
g_static_mutex_unlock(&log_tags_lock);
}
Test(logqueue, log_queue_fifo_rewind_all_and_memory_usage)
{
LogQueue *q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
log_queue_set_use_backlog(q, TRUE);
StatsClusterKey sc_key;
stats_lock();
stats_cluster_logpipe_key_set(&sc_key, SCS_DESTINATION, q->persist_name, NULL );
stats_register_counter(1, &sc_key, SC_TYPE_MEMORY_USAGE, &q->memory_usage);
stats_unlock();
feed_some_messages(q, 1);
gint size_when_single_msg = stats_counter_get(q->memory_usage);
feed_some_messages(q, 9);
cr_assert_eq(stats_counter_get(q->memory_usage), 10*size_when_single_msg);
send_some_messages(q, 10);
cr_assert_eq(stats_counter_get(q->memory_usage), 0);
log_queue_rewind_backlog_all(q);
cr_assert_eq(stats_counter_get(q->memory_usage), 10*size_when_single_msg);
log_queue_unref(q);
}
void fserve_scan (time_t now)
{
avl_node *node;
avl_tree_wlock (fh_cache);
node = avl_get_first (fh_cache);
while (node)
{
fh_node *fh = node->key;
node = avl_get_next (node);
thread_mutex_lock (&fh->lock);
if (global.running != ICE_RUNNING)
fh->expire = 0;
if (now == (time_t)0)
{
fh->expire = 0;
thread_mutex_unlock (&fh->lock);
continue;
}
if (fh->finfo.limit)
{
fbinfo *finfo = &fh->finfo;
if (fh->stats == 0)
{
int len = strlen (finfo->mount) + 10;
char *str = alloca (len);
char buf[20];
snprintf (str, len, "%s-%s", (finfo->flags & FS_FALLBACK) ? "fallback" : "file", finfo->mount);
fh->stats = stats_handle (str);
stats_set_flags (fh->stats, "fallback", "file", STATS_COUNTERS|STATS_HIDDEN);
stats_set_flags (fh->stats, "outgoing_kbitrate", "0", STATS_COUNTERS|STATS_HIDDEN);
snprintf (buf, sizeof (buf), "%d", fh->refcount);
stats_set_flags (fh->stats, "listeners", buf, STATS_GENERAL|STATS_HIDDEN);
snprintf (buf, sizeof (buf), "%d", fh->peak);
stats_set_flags (fh->stats, "listener_peak", buf, STATS_GENERAL|STATS_HIDDEN);
fh->prev_count = fh->refcount;
}
else
{
stats_lock (fh->stats, NULL);
if (fh->prev_count != fh->refcount)
{
fh->prev_count = fh->refcount;
stats_set_args (fh->stats, "listeners", "%ld", fh->refcount);
stats_set_args (fh->stats, "listener_peak", "%ld", fh->peak);
}
}
if (fh->stats_update <= now)
{
fh->stats_update = now + 5;
stats_set_args (fh->stats, "outgoing_kbitrate", "%ld",
(long)((8 * rate_avg (fh->out_bitrate))/1024));
}
stats_release (fh->stats);
}
if (fh->refcount == 0 && fh->expire >= 0 && now >= fh->expire)
{
DEBUG1 ("timeout of %s", fh->finfo.mount);
if (fh->stats)
{
stats_lock (fh->stats, NULL);
stats_set (fh->stats, NULL, NULL);
}
remove_fh_from_cache (fh);
thread_mutex_unlock (&fh->lock);
_delete_fh (fh);
continue;
}
thread_mutex_unlock (&fh->lock);
}
avl_tree_unlock (fh_cache);
}
static void
log_source_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options, gpointer user_data)
{
LogSource *self = (LogSource *) s;
gint i;
msg_set_context(msg);
if (msg->timestamps[LM_TS_STAMP].tv_sec == -1 || !self->options->keep_timestamp)
msg->timestamps[LM_TS_STAMP] = msg->timestamps[LM_TS_RECVD];
g_assert(msg->timestamps[LM_TS_STAMP].zone_offset != -1);
/* $HOST setup */
log_source_mangle_hostname(self, msg);
/* $PROGRAM override */
if (self->options->program_override)
{
if (self->options->program_override_len < 0)
self->options->program_override_len = strlen(self->options->program_override);
log_msg_set_value(msg, LM_V_PROGRAM, self->options->program_override, self->options->program_override_len);
}
/* $HOST override */
if (self->options->host_override)
{
if (self->options->host_override_len < 0)
self->options->host_override_len = strlen(self->options->host_override);
log_msg_set_value(msg, LM_V_HOST, self->options->host_override, self->options->host_override_len);
}
/* source specific tags */
if (self->options->tags)
{
for (i = 0; i < self->options->tags->len; i++)
{
log_msg_set_tag_by_id(msg, g_array_index(self->options->tags, LogTagId, i));
}
}
log_msg_set_tag_by_id(msg, self->options->source_group_tag);
/* stats counters */
if (stats_check_level(2))
{
stats_lock();
stats_register_and_increment_dynamic_counter(2, SCS_HOST | SCS_SOURCE, NULL, log_msg_get_value(msg, LM_V_HOST, NULL), msg->timestamps[LM_TS_RECVD].tv_sec);
if (stats_check_level(3))
{
stats_register_and_increment_dynamic_counter(3, SCS_SENDER | SCS_SOURCE, NULL, log_msg_get_value(msg, LM_V_HOST_FROM, NULL), msg->timestamps[LM_TS_RECVD].tv_sec);
stats_register_and_increment_dynamic_counter(3, SCS_PROGRAM | SCS_SOURCE, NULL, log_msg_get_value(msg, LM_V_PROGRAM, NULL), msg->timestamps[LM_TS_RECVD].tv_sec);
}
stats_unlock();
}
stats_syslog_process_message_pri(msg->pri);
/* message setup finished, send it out */
stats_counter_inc(self->recvd_messages);
stats_counter_set(self->last_message_seen, msg->timestamps[LM_TS_RECVD].tv_sec);
log_pipe_forward_msg(s, msg, path_options);
msg_set_context(NULL);
if (accurate_nanosleep && self->threaded && self->window_full_sleep_nsec > 0 && !log_source_free_to_send(self))
{
struct timespec ts;
/* wait one 0.1msec in the hope that the buffer clears up */
ts.tv_sec = 0;
ts.tv_nsec = self->window_full_sleep_nsec;
nanosleep(&ts, NULL);
}
}
static void
log_source_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options, gpointer user_data)
{
LogSource *self = (LogSource *) s;
LogPathOptions local_options = *path_options;
gint old_window_size;
gint i;
msg_set_context(msg);
if (msg->timestamps[LM_TS_STAMP].tv_sec == -1 || !self->options->keep_timestamp)
msg->timestamps[LM_TS_STAMP] = msg->timestamps[LM_TS_RECVD];
g_assert(msg->timestamps[LM_TS_STAMP].zone_offset != -1);
ack_tracker_track_msg(self->ack_tracker, msg);
/* $HOST setup */
log_source_mangle_hostname(self, msg);
/* $PROGRAM override */
if (self->options->program_override)
{
if (self->options->program_override_len < 0)
self->options->program_override_len = strlen(self->options->program_override);
log_msg_set_value(msg, LM_V_PROGRAM, self->options->program_override, self->options->program_override_len);
}
/* $HOST override */
if (self->options->host_override)
{
if (self->options->host_override_len < 0)
self->options->host_override_len = strlen(self->options->host_override);
log_msg_set_value(msg, LM_V_HOST, self->options->host_override, self->options->host_override_len);
}
/* source specific tags */
if (self->options->tags)
{
for (i = 0; i < self->options->tags->len; i++)
{
log_msg_set_tag_by_id(msg, g_array_index(self->options->tags, LogTagId, i));
}
}
log_msg_set_tag_by_id(msg, self->options->source_group_tag);
/* stats counters */
if (stats_check_level(2))
{
stats_lock();
stats_register_and_increment_dynamic_counter(2, SCS_HOST | SCS_SOURCE, NULL, log_msg_get_value(msg, LM_V_HOST, NULL), msg->timestamps[LM_TS_RECVD].tv_sec);
if (stats_check_level(3))
{
stats_register_and_increment_dynamic_counter(3, SCS_SENDER | SCS_SOURCE, NULL, log_msg_get_value(msg, LM_V_HOST_FROM, NULL), msg->timestamps[LM_TS_RECVD].tv_sec);
stats_register_and_increment_dynamic_counter(3, SCS_PROGRAM | SCS_SOURCE, NULL, log_msg_get_value(msg, LM_V_PROGRAM, NULL), msg->timestamps[LM_TS_RECVD].tv_sec);
}
stats_unlock();
}
stats_syslog_process_message_pri(msg->pri);
/* message setup finished, send it out */
/* NOTE: we start by enabling flow-control, thus we need an acknowledgement */
local_options.ack_needed = TRUE;
log_msg_ref(msg);
log_msg_add_ack(msg, &local_options);
msg->ack_func = log_source_msg_ack;
old_window_size = g_atomic_counter_exchange_and_add(&self->window_size, -1);
/*
* NOTE: this assertion validates that the source is not overflowing its
* own flow-control window size, decreased above, by the atomic statement.
*
* If the _old_ value is zero, that means that the decrement operation
* above has decreased the value to -1.
*/
g_assert(old_window_size > 0);
stats_counter_inc(self->recvd_messages);
stats_counter_set(self->last_message_seen, msg->timestamps[LM_TS_RECVD].tv_sec);
log_pipe_forward_msg(s, msg, &local_options);
msg_set_context(NULL);
if (accurate_nanosleep && self->threaded && self->window_full_sleep_nsec > 0 && !log_source_free_to_send(self))
{
struct timespec ts;
/* wait one 0.1msec in the hope that the buffer clears up */
ts.tv_sec = 0;
ts.tv_nsec = self->window_full_sleep_nsec;
nanosleep(&ts, NULL);
}
}
static gboolean
afmongodb_dd_init(LogPipe *s)
{
MongoDBDestDriver *self = (MongoDBDestDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
ValuePairsTransformSet *vpts;
if (!log_dest_driver_init_method(s))
return FALSE;
if (cfg)
self->time_reopen = cfg->time_reopen;
if (!self->vp)
{
self->vp = value_pairs_new();
value_pairs_add_scope(self->vp, "selected-macros");
value_pairs_add_scope(self->vp, "nv-pairs");
}
/* Always replace a leading dot with an underscore. */
vpts = value_pairs_transform_set_new(".*");
value_pairs_transform_set_add_func(vpts, value_pairs_new_transform_replace(".", "_"));
value_pairs_add_transforms(self->vp, vpts);
if (self->port != MONGO_CONN_LOCAL)
{
if (self->address)
{
gchar *srv = g_strdup_printf ("%s:%d", self->address,
(self->port) ? self->port : 27017);
self->servers = g_list_prepend (self->servers, srv);
g_free (self->address);
}
if (!self->servers)
afmongodb_dd_set_servers((LogDriver *)self, g_list_append (NULL, g_strdup ("127.0.0.1:27017")));
self->address = NULL;
self->port = 27017;
if (!mongo_util_parse_addr(g_list_nth_data(self->servers, 0),
&self->address,
&self->port))
{
msg_error("Cannot parse the primary host",
evt_tag_str("primary", g_list_nth_data(self->servers, 0)),
NULL);
return FALSE;
}
}
if (self->port == MONGO_CONN_LOCAL)
msg_verbose("Initializing MongoDB destination",
evt_tag_str("address", self->address),
evt_tag_str("database", self->db),
evt_tag_str("collection", self->coll),
NULL);
else
msg_verbose("Initializing MongoDB destination",
evt_tag_str("address", self->address),
evt_tag_int("port", self->port),
evt_tag_str("database", self->db),
evt_tag_str("collection", self->coll),
NULL);
self->queue = log_dest_driver_acquire_queue(&self->super, afmongodb_dd_format_persist_name(self));
stats_lock();
stats_register_counter(0, SCS_MONGODB | SCS_DESTINATION, self->super.super.id,
afmongodb_dd_format_stats_instance(self),
SC_TYPE_STORED, &self->stored_messages);
stats_register_counter(0, SCS_MONGODB | SCS_DESTINATION, self->super.super.id,
afmongodb_dd_format_stats_instance(self),
SC_TYPE_DROPPED, &self->dropped_messages);
stats_unlock();
log_queue_set_counters(self->queue, self->stored_messages, self->dropped_messages);
afmongodb_dd_start_thread(self);
return TRUE;
}