static gboolean
log_filter_pipe_init(LogPipe *s)
{
LogFilterPipe *self = (LogFilterPipe *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (self->expr->init)
self->expr->init(self->expr, log_pipe_get_config(s));
if (!self->name)
self->name = cfg_tree_get_rule_name(&cfg->tree, ENC_FILTER, s->expr_node);
return TRUE;
}
static gboolean
log_rewrite_init_method(LogPipe *s)
{
LogRewrite *self = (LogRewrite *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (self->condition && self->condition->init)
self->condition->init(self->condition, log_pipe_get_config(s));
if (!self->name)
self->name = cfg_tree_get_rule_name(&cfg->tree, ENC_REWRITE, s->expr_node);
return TRUE;
}
static gboolean
afinter_source_init(LogPipe *s)
{
AFInterSource *self = (AFInterSource *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_source_init(s))
return FALSE;
self->mark_freq = cfg->mark_freq;
afinter_postpone_mark(self->mark_freq);
self->mark_timer.expires = next_mark_target;
/* post event is used by other threads and can only be unregistered if
* current_afinter_source is set to NULL in a thread safe manner */
iv_event_register(&self->post);
iv_event_register(&self->schedule_wakeup);
afinter_source_start_watches(self);
g_static_mutex_lock(&internal_msg_lock);
current_internal_source = self;
g_static_mutex_unlock(&internal_msg_lock);
return TRUE;
}
static gboolean
afunix_sd_acquire_socket(AFSocketSourceDriver *s, gint *result_fd)
{
AFUnixSourceDriver *self = (AFUnixSourceDriver *) s;
gboolean fd_ok;
GlobalConfig *cfg = log_pipe_get_config(&s->super.super.super);
fd_ok = afunix_sd_acquire_named_socket(s, result_fd, self->filename);
if (fd_ok && (*result_fd == -1) && (strcmp(self->filename, "/dev/log") == 0))
{
fd_ok = afunix_sd_acquire_named_socket(s, result_fd, "/run/systemd/journal/syslog");
if (fd_ok && *result_fd > -1)
{
if (cfg_is_config_version_older(cfg, 0x0304))
{
msg_warning("WARNING: systemd detected while using /dev/log; migrating automatically to /run/systemd/journal/syslog. Please update your configuration to use the system() source.",
evt_tag_str("id", self->super.super.super.id),
NULL);
g_free(self->filename);
self->filename = g_strdup("/run/systemd/journal/syslog");
return TRUE;
}
}
}
if (!fd_ok)
msg_debug("Failed to acquire systemd socket, trying to open ourselves",
evt_tag_str("filename", self->filename),
NULL);
return fd_ok;
}
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 (!self->user || !self->password)
{
msg_error("Error initializing AMQP destination: username and password MUST be set!",
evt_tag_str("driver", self->super.super.super.id),
NULL);
return FALSE;
}
log_template_options_init(&self->template_options, cfg);
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);
return log_threaded_dest_driver_start(s);
}
static gboolean
_setup_auth_header(LogPipe *s)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
HttpAuthHeader *prev_auth_header = cfg_persist_config_fetch(cfg, _format_auth_header_name(s));
if (prev_auth_header)
{
http_auth_header_free(self->auth_header);
self->auth_header = prev_auth_header;
msg_debug("Auth header instance found in persist cfg",
log_pipe_location_tag(s));
return TRUE;
}
if (self->auth_header)
{
if (!http_auth_header_init(self->auth_header))
{
return FALSE;
}
_load_auth_header(s);
}
return TRUE;
}
static gboolean
afsocket_sd_setup_reader_options(AFSocketSourceDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
if (self->transport_mapper->sock_type == SOCK_STREAM && !self->window_size_initialized)
{
/* distribute the window evenly between each of our possible
* connections. This is quite pessimistic and can result in very low
* window sizes. Increase that but warn the user at the same time
*/
self->reader_options.super.init_window_size /= self->max_connections;
if (self->reader_options.super.init_window_size < 100)
{
msg_warning("WARNING: window sizing for tcp sources were changed in " VERSION_3_3 ", the configuration value was divided by the value of max-connections(). The result was too small, clamping to 100 entries. Ensure you have a proper log_fifo_size setting to avoid message loss.",
evt_tag_int("orig_log_iw_size", self->reader_options.super.init_window_size),
evt_tag_int("new_log_iw_size", 100),
evt_tag_int("min_log_fifo_size", 100 * self->max_connections),
NULL);
self->reader_options.super.init_window_size = 100;
}
self->window_size_initialized = TRUE;
}
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
return TRUE;
}
static gboolean
afprogram_dd_init(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
log_writer_options_init(&self->writer_options, cfg, 0);
const gboolean restore_successful = afprogram_dd_restore_reload_store_item(self, cfg);
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_FILE, s->cfg);
log_writer_set_options(self->writer,
s,
&self->writer_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->process_info.cmdline->str);
log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super,
afprogram_dd_format_queue_persist_name(self)));
if (!log_pipe_init((LogPipe *) self->writer))
{
log_pipe_unref((LogPipe *) self->writer);
return FALSE;
}
log_pipe_append(&self->super.super.super, (LogPipe *) self->writer);
return restore_successful ? TRUE : afprogram_dd_reopen(self);
}
static gboolean
afprogram_dd_deinit(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
if (self->writer)
log_pipe_deinit((LogPipe *) self->writer);
child_manager_unregister(self->process_info.pid);
if (self->keep_alive)
{
afprogram_dd_store_reload_store_item(self, cfg);
}
else
{
afprogram_dd_kill_child(self);
if (self->writer)
log_pipe_unref((LogPipe *) self->writer);
}
if (self->writer)
{
self->writer = NULL;
}
return log_dest_driver_deinit_method(s);
}
static gboolean
afsocket_sd_restore_kept_alive_connections(AFSocketSourceDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
/* fetch persistent connections first */
if (self->connections_kept_alive_accross_reloads)
{
GList *p = NULL;
self->connections = cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, FALSE));
self->num_connections = 0;
for (p = self->connections; p; p = p->next)
{
afsocket_sc_set_owner((AFSocketSourceConnection *) p->data, self);
if (log_pipe_init((LogPipe *) p->data))
{
self->num_connections++;
}
else
{
AFSocketSourceConnection *sc = (AFSocketSourceConnection *)p->data;
self->connections = g_list_remove(self->connections, sc);
afsocket_sd_kill_connection((AFSocketSourceConnection *)sc);
}
}
}
return TRUE;
}
static gboolean
afprogram_dd_init(LogPipe *s)
{
AFProgramDestDriver *self = (AFProgramDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_dest_driver_init_method(s))
return FALSE;
log_writer_options_init(&self->writer_options, cfg, 0);
if (!self->writer)
self->writer = log_writer_new(LW_FORMAT_FILE);
log_writer_set_options(self->writer,
s,
&self->writer_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->cmdline->str);
log_writer_set_queue(self->writer, log_dest_driver_acquire_queue(&self->super, afprogram_dd_format_persist_name(self)));
log_pipe_init((LogPipe *) self->writer, NULL);
log_pipe_append(&self->super.super.super, (LogPipe *) self->writer);
return afprogram_dd_reopen(self);
}
gboolean
afsocket_dd_deinit(LogPipe *s)
{
AFSocketDestDriver *self = (AFSocketDestDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (self->reconnect_timer)
g_source_remove(self->reconnect_timer);
if (self->source_id && g_source_remove(self->source_id))
{
msg_verbose("Closing connecting fd",
evt_tag_int("fd", self->fd),
NULL);
close(self->fd);
}
if (self->writer)
{
log_pipe_deinit(self->writer);
}
if (self->flags & AFSOCKET_KEEP_ALIVE)
{
cfg_persist_config_add(cfg, afsocket_dd_format_persist_name(self, self->dest_name, FALSE), self->writer, -1, (GDestroyNotify) log_pipe_unref, FALSE);
self->writer = NULL;
}
return TRUE;
}
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;
}
gboolean
http_dd_init(LogPipe *s)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (self->load_balancer->num_targets == 0)
http_load_balancer_add_target(self->load_balancer, HTTP_DEFAULT_URL);
if (self->load_balancer->num_targets > 1 && s->persist_name == NULL)
{
msg_warning("WARNING: your http() driver instance uses multiple urls without persist-name(). "
"It is recommended that you set persist-name() in this case as syslog-ng will be "
"using the first URL in urls() to register persistent data, such as the disk queue "
"name, which might change",
evt_tag_str("url", self->load_balancer->targets[0].url));
}
/* we need to set up url before we call the inherited init method, so our stats key is correct */
self->url = self->load_balancer->targets[0].url;
if (!_setup_auth_header(s))
return FALSE;
if (!log_threaded_dest_driver_init_method(s))
return FALSE;
log_template_options_init(&self->template_options, cfg);
http_load_balancer_set_recovery_timeout(self->load_balancer, self->super.time_reopen);
return log_threaded_dest_driver_start_workers(&self->super);
}
static void
afsocket_dd_restore_connection(AFSocketDestDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
self->writer = cfg_persist_config_fetch(cfg, afsocket_dd_format_persist_name(self, FALSE));
}
/* NOTE: runs in the main thread */
static void
affile_sd_notify(LogPipe *s, gint notify_code, gpointer user_data)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
switch (notify_code)
{
case NC_FILE_MOVED:
{
msg_verbose("Follow-mode file source moved, tracking of the new file is started",
evt_tag_str("filename", self->filename->str),
NULL);
log_pipe_deinit((LogPipe *) self->reader);
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
if (affile_sd_open_file(self, self->filename->str, &fd))
{
LogProtoServer *proto;
PollEvents *poll_events;
poll_events = affile_sd_construct_poll_events(self, fd);
if (!poll_events)
break;
proto = affile_sd_construct_proto(self, fd);
self->reader = log_reader_new(self->super.super.super.cfg);
log_reader_reopen(self->reader, proto, poll_events);
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL1,
SCS_FILE,
self->super.super.id,
self->filename->str);
log_reader_set_immediate_check(self->reader);
log_pipe_append((LogPipe *) self->reader, s);
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd),
NULL);
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
}
affile_sd_recover_state(s, cfg, proto);
}
break;
}
default:
break;
}
}
static gboolean
log_source_group_init(LogPipe *s)
{
LogSourceGroup *self = (LogSourceGroup *) s;
LogDriver *p;
GlobalConfig *cfg = log_pipe_get_config(s);
gint id = 0;
for (p = self->drivers; p; p = p->drv_next)
{
p->group = g_strdup(self->name);
if (!p->id)
p->id = g_strdup_printf("%s#%d", self->name, id++);
if (!log_pipe_init(&p->super, cfg))
{
msg_error("Error initializing source driver",
evt_tag_str("source", self->name),
evt_tag_str("id", p->id),
NULL);
goto deinit_all;
}
log_pipe_append(&p->super, s);
}
stats_register_counter(0, SCS_SOURCE | SCS_GROUP, self->name, NULL, SC_TYPE_PROCESSED, &self->processed_messages);
return TRUE;
deinit_all:
for (p = self->drivers; p; p = p->drv_next)
log_pipe_deinit(&p->super);
return FALSE;
}
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;
log_template_options_init(&self->template_options, cfg);
/* 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_prefix(".", "_"));
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);
return log_threaded_dest_driver_start(s);
}
static gboolean
afsocket_dd_setup_writer_options(AFSocketDestDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
log_writer_options_init(&self->writer_options, cfg, 0);
return TRUE;
}
static gboolean
afsocket_sd_open_listener(AFSocketSourceDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
gint sock;
gboolean res = FALSE;
/* ok, we have connection list, check if we need to open a listener */
sock = -1;
if (self->transport_mapper->sock_type == SOCK_STREAM)
{
if (self->connections_kept_alive_accross_reloads)
{
/* NOTE: this assumes that fd 0 will never be used for listening fds,
* main.c opens fd 0 so this assumption can hold */
sock = GPOINTER_TO_UINT(cfg_persist_config_fetch(cfg, afsocket_sd_format_persist_name(self, TRUE))) - 1;
}
if (sock == -1)
{
if (!afsocket_sd_acquire_socket(self, &sock))
return self->super.super.optional;
if (sock == -1 && !transport_mapper_open_socket(self->transport_mapper, self->socket_options, self->bind_addr, AFSOCKET_DIR_RECV, &sock))
return self->super.super.optional;
}
/* set up listening source */
if (listen(sock, self->listen_backlog) < 0)
{
msg_error("Error during listen()",
evt_tag_errno(EVT_TAG_OSERROR, errno),
NULL);
close(sock);
return FALSE;
}
self->fd = sock;
afsocket_sd_start_watches(self);
res = TRUE;
}
else
{
if (!self->connections)
{
if (!afsocket_sd_acquire_socket(self, &sock))
return self->super.super.optional;
if (sock == -1 && !transport_mapper_open_socket(self->transport_mapper, self->socket_options, self->bind_addr, AFSOCKET_DIR_RECV, &sock))
return self->super.super.optional;
}
self->fd = -1;
/* we either have self->connections != NULL, or sock contains a new fd */
if (self->connections || afsocket_sd_process_connection(self, NULL, self->bind_addr, sock))
res = TRUE;
}
return res;
}
/* NOTE: runs in the main thread */
static void
affile_sd_notify(LogPipe *s, LogPipe *sender, gint notify_code, gpointer user_data)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
switch (notify_code)
{
case NC_FILE_MOVED:
{
msg_verbose("Follow-mode file source moved, tracking of the new file is started",
evt_tag_str("filename", self->filename->str),
NULL);
log_pipe_deinit(self->reader);
log_pipe_unref(self->reader);
if (affile_sd_open_file(self, self->filename->str, &fd))
{
LogTransport *transport;
LogProto *proto;
transport = log_transport_plain_new(fd, 0);
transport->timeout = 10;
proto = affile_sd_construct_proto(self, transport);
self->reader = log_reader_new(proto);
log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_FILE, self->super.super.id, self->filename->str);
log_reader_set_follow_filename(self->reader, self->filename->str);
log_reader_set_immediate_check(self->reader);
log_pipe_append(self->reader, s);
if (!log_pipe_init(self->reader, cfg))
{
msg_error("Error initializing log_reader, closing fd",
evt_tag_int("fd", fd),
NULL);
log_pipe_unref(self->reader);
self->reader = NULL;
close(fd);
}
affile_sd_recover_state(s, cfg, proto);
}
else
{
self->reader = NULL;
}
break;
}
default:
break;
}
}
gboolean
afsocket_sd_deinit(LogPipe *s)
{
AFSocketSourceDriver *self = (AFSocketSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if ((self->flags & AFSOCKET_KEEP_ALIVE) == 0 || !cfg->persist)
{
afsocket_sd_kill_connection_list(self->connections);
}
else
{
GList *p;
/* for AFSOCKET_STREAM source drivers this is a list, for
* AFSOCKET_DGRAM this is a single connection */
for (p = self->connections; p; p = p->next)
{
log_pipe_deinit((LogPipe *) p->data);
}
cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, FALSE), self->connections, (GDestroyNotify) afsocket_sd_kill_connection_list, FALSE);
}
self->connections = NULL;
if (self->flags & AFSOCKET_STREAM)
{
afsocket_sd_stop_watches(self);
if ((self->flags & AFSOCKET_KEEP_ALIVE) == 0)
{
msg_verbose("Closing listener fd",
evt_tag_int("fd", self->fd),
NULL);
close(self->fd);
}
else
{
/* NOTE: the fd is incremented by one when added to persistent config
* as persist config cannot store NULL */
cfg_persist_config_add(cfg, afsocket_sd_format_persist_name(self, TRUE), GUINT_TO_POINTER(self->fd + 1), afsocket_sd_close_fd, FALSE);
}
}
else if (self->flags & AFSOCKET_DGRAM)
{
/* we don't need to close the listening fd here as we have a
* single connection which will close it */
;
}
if (!log_src_driver_deinit_method(s))
return FALSE;
return TRUE;
}
static void
_save_auth_header_to_persist_file(LogPipe *s)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
const gchar *persist_name = _format_auth_header_name(s);
const gchar *auth_header_str = http_auth_header_get_as_string(self->auth_header);
persist_state_alloc_string(cfg->state, persist_name, auth_header_str, -1);
}
void
afstomp_dd_set_body(LogDriver *d, const gchar *body)
{
STOMPDestDriver *self = (STOMPDestDriver *) d;
GlobalConfig *cfg = log_pipe_get_config((LogPipe *)d);
if (!self->body_template)
self->body_template = log_template_new(cfg, NULL);
log_template_compile(self->body_template, body, NULL);
}
static LogPipe *
date_parser_clone(LogPipe *s)
{
DateParser *self = (DateParser *) s;
LogParser *cloned;
cloned = date_parser_new(log_pipe_get_config(&self->super.super));
date_parser_set_format(cloned, self->date_format);
date_parser_set_timezone(cloned, self->date_tz);
date_parser_set_time_stamp(cloned, self->time_stamp);
log_parser_set_template(cloned, log_template_ref(self->super.template));
gboolean
http_dd_deinit(LogPipe *s)
{
HTTPDestinationDriver *self = (HTTPDestinationDriver *)s;
GlobalConfig *cfg = log_pipe_get_config(s);
cfg_persist_config_add(cfg, _format_auth_header_name(s), self->auth_header, (GDestroyNotify) http_auth_header_free,
FALSE);
self->auth_header = NULL;
return log_threaded_dest_driver_deinit_method(s);
}
/* consumes the reference in @q */
static void
log_dest_driver_release_queue_method(LogDestDriver *self, LogQueue *q, gpointer user_data)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super);
/* we only save the LogQueue instance if it contains data */
if (q->persist_name && log_queue_keep_on_reload(q) > 0)
cfg_persist_config_add(cfg, q->persist_name, q, (GDestroyNotify) log_queue_unref, FALSE);
else
log_queue_unref(q);
}
static void
afsocket_dd_save_connection(AFSocketDestDriver *self)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super.super);
if (self->connections_kept_alive_accross_reloads)
{
cfg_persist_config_add(cfg, afsocket_dd_format_persist_name(self, FALSE), self->writer, (GDestroyNotify) log_pipe_unref, FALSE);
self->writer = NULL;
}
}
static gboolean
afprogram_sd_init(LogPipe *s)
{
AFProgramSourceDriver *self = (AFProgramSourceDriver *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
gint fd;
if (!log_src_driver_init_method(s))
return FALSE;
if (cfg)
log_reader_options_init(&self->reader_options, cfg, self->super.super.group);
msg_verbose("Starting source program",
evt_tag_str("cmdline", self->process_info.cmdline->str));
if (!afprogram_popen(&self->process_info, G_IO_IN, &fd))
return FALSE;
/* parent */
child_manager_register(self->process_info.pid, afprogram_sd_exit, log_pipe_ref(&self->super.super.super),
(GDestroyNotify) log_pipe_unref);
g_fd_set_nonblock(fd, TRUE);
g_fd_set_cloexec(fd, TRUE);
if (!self->reader)
{
LogTransport *transport;
transport = log_transport_pipe_new(fd);
self->reader = log_reader_new(s->cfg);
log_reader_reopen(self->reader, log_proto_text_server_new(transport, &self->reader_options.proto_options.super),
poll_fd_events_new(fd));
log_reader_set_options(self->reader,
s,
&self->reader_options,
STATS_LEVEL0,
SCS_PROGRAM,
self->super.super.id,
self->process_info.cmdline->str);
}
log_pipe_append((LogPipe *) self->reader, &self->super.super.super);
if (!log_pipe_init((LogPipe *) self->reader))
{
msg_error("Error initializing program source, closing fd",
evt_tag_int("fd", fd));
log_pipe_unref((LogPipe *) self->reader);
self->reader = NULL;
close(fd);
return FALSE;
}
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;
}
