Collaboration diagram for Logger Routines:

Data Structures
struct	switch_log_node_t
	Log Data. More...

struct	switch_log_json_format_item_t
	JSON Log formatting data item. More...

struct	switch_log_json_format_t
	JSON Log formatting data. More...

Macros
#define	switch_log_check_mask(_mask, _level) (_mask & ((size_t)1 << _level))

Typedefs
typedef switch_status_t(*	switch_log_function_t) (const switch_log_node_t *node, switch_log_level_t level)

Functions
cJSON *	switch_log_node_to_json (const switch_log_node_t node, int log_level, switch_log_json_format_t json_format, switch_event_t *chan_vars)
	Convert a log node to JSON object. Destroy JSON object when finished. More...

switch_status_t	switch_log_init (_In_ switch_memory_pool_t *pool, _In_ switch_bool_t colorize)
	Initilize the logging engine. More...

switch_status_t	switch_log_shutdown (void)
	Shut down the logging engine. More...

void	switch_log_printf (_In_ switch_text_channel_t channel, _In_z_ const char file, _In_z_ const char func, _In_ int line, _In_opt_z_ const char userdata, _In_ switch_log_level_t level, _In_z_ _Printf_format_string_ const char fmt,...) PRINTF_FUNCTION(7
	Write log data to the logging engine. More...

void void	switch_log_vprintf (_In_ switch_text_channel_t channel, _In_z_ const char file, _In_z_ const char func, _In_ int line, _In_opt_z_ const char userdata, _In_ switch_log_level_t level, const char fmt, va_list ap)
	Write log data to the logging engine. More...

void	switch_log_meta_printf (switch_text_channel_t channel, const char file, const char func, int line, const char userdata, switch_log_level_t level, cJSON meta, const char fmt,...) PRINTF_FUNCTION(8
	Write log data to the logging engine w/ optional JSON metadata. More...

void void	switch_log_meta_vprintf (_In_ switch_text_channel_t channel, _In_z_ const char file, _In_z_ const char func, _In_ int line, _In_opt_z_ const char userdata, _In_ switch_log_level_t level, cJSON meta, const char fmt, va_list ap)
	Write log data to the logging engine w/ optional JSON metadata. More...

switch_status_t	switch_log_bind_logger (_In_ switch_log_function_t function, _In_ switch_log_level_t level, _In_ switch_bool_t is_console)
	Shut down the logging engine. More...

switch_status_t	switch_log_unbind_logger (_In_ switch_log_function_t function)

_Ret_z_ const char *	switch_log_level2str (_In_ switch_log_level_t level)
	Return the name of the specified log level. More...

switch_log_level_t	switch_log_str2level (_In_z_ const char *str)
	Return the level number of the specified log level name. More...

uint32_t	switch_log_str2mask (_In_z_ const char *str)

switch_log_node_t *	switch_log_node_dup (const switch_log_node_t *node)

void	switch_log_node_free (switch_log_node_t **pnode)

Variables
char *	switch_log_node_t::data

char	switch_log_node_t::file [80]

uint32_t	switch_log_node_t::line

char	switch_log_node_t::func [80]

switch_log_level_t	switch_log_node_t::level

switch_time_t	switch_log_node_t::timestamp

char *	switch_log_node_t::content

char *	switch_log_node_t::userdata

switch_text_channel_t	switch_log_node_t::channel

switch_log_level_t	switch_log_node_t::slevel

switch_event_t *	switch_log_node_t::tags

int64_t	switch_log_node_t::sequence

cJSON *	switch_log_node_t::meta

const char *	switch_log_json_format_item_t::name

const char *	switch_log_json_format_item_t::value

switch_log_json_format_item_t	switch_log_json_format_t::version

switch_log_json_format_item_t	switch_log_json_format_t::host

switch_log_json_format_item_t	switch_log_json_format_t::timestamp

switch_log_json_format_item_t	switch_log_json_format_t::level

switch_log_json_format_item_t	switch_log_json_format_t::ident

switch_log_json_format_item_t	switch_log_json_format_t::pid

switch_log_json_format_item_t	switch_log_json_format_t::uuid

switch_log_json_format_item_t	switch_log_json_format_t::file

switch_log_json_format_item_t	switch_log_json_format_t::line

switch_log_json_format_item_t	switch_log_json_format_t::function

switch_log_json_format_item_t	switch_log_json_format_t::full_message

switch_log_json_format_item_t	switch_log_json_format_t::short_message

const char *	switch_log_json_format_t::custom_field_prefix

double	switch_log_json_format_t::timestamp_divisor

switch_log_json_format_item_t	switch_log_json_format_t::sequence

Detailed Description

Macro Definition Documentation

◆ switch_log_check_mask

#define switch_log_check_mask	(	_mask,
		_level
	)	(_mask & ((size_t)1 << _level))

Definition at line 219 of file switch_log.h.

Typedef Documentation

◆ switch_log_function_t

typedef switch_status_t(* switch_log_function_t) (const switch_log_node_t *node, switch_log_level_t level)

Definition at line 104 of file switch_log.h.

Function Documentation

◆ switch_log_bind_logger()

switch_status_t switch_log_bind_logger	(	_In_ switch_log_function_t	function,
		_In_ switch_log_level_t	level,
		_In_ switch_bool_t	is_console
	)

Shut down the logging engine.

Note: to be called at application termination by the core

◆ switch_log_init()

switch_status_t switch_log_init	(	_In_ switch_memory_pool_t *	pool,
		_In_ switch_bool_t	colorize
	)

Initilize the logging engine.

Parameters

pool	the memory pool to use

Note: to be called at application startup by the core

Referenced by switch_core_init().

◆ switch_log_level2str()

_Ret_z_ const char* switch_log_level2str ( _In_ switch_log_level_t level )

Return the name of the specified log level.

Parameters

level the level

Returns: the name of the log level

◆ switch_log_meta_printf()

void switch_log_meta_printf	(	switch_text_channel_t	channel,
		const char *	file,
		const char *	func,
		int	line,
		const char *	userdata,
		switch_log_level_t	level,
		cJSON **	meta,
		const char *	fmt,
			...
	)

Write log data to the logging engine w/ optional JSON metadata.

Parameters

channel	the log channel to write to
file	the current file
func	the current function
line	the current line
userdata	ununsed
level	the current log level
meta	log metadata - consumed by this function
fmt	desired format
...	variable args

Note: there are channel macros to supply the first 4 parameters (SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_LOG_CLEAN, ...)

See also: switch_types.h

◆ switch_log_meta_vprintf()

void void switch_log_meta_vprintf	(	_In_ switch_text_channel_t	channel,
		_In_z_ const char *	file,
		_In_z_ const char *	func,
		_In_ int	line,
		_In_opt_z_ const char *	userdata,
		_In_ switch_log_level_t	level,
		cJSON **	meta,
		const char *	fmt,
		va_list	ap
	)

Write log data to the logging engine w/ optional JSON metadata.

Parameters

channel	the log channel to write to
file	the current file
func	the current function
line	the current line
userdata	ununsed
level	the current log level
meta	log metadata - consumed by this function
fmt	desired format
ap	variable args

Note: there are channel macros to supply the first 4 parameters (SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_LOG_CLEAN, ...)

See also: switch_types.h

◆ switch_log_node_dup()

switch_log_node_t* switch_log_node_dup ( const switch_log_node_t * node )

Definition at line 267 of file switch_log.c.

References cJSON_True, switch_log_node_t::content, switch_log_node_t::data, switch_log_node_t::meta, switch_assert, switch_event_dup(), switch_log_node_alloc(), switch_log_node_t::tags, and switch_log_node_t::userdata.

 {
         switch_log_node_t *newnode = switch_log_node_alloc();
 
         *newnode = *node;
         newnode->content = NULL;
 
         if (node->data) {
                 newnode->data = strdup(node->data);
                 switch_assert(newnode->data);
 
                 // content is a pointer inside data; need to calculate the new pointer
                 if (node->content && node->content >= node->data) {
                         newnode->content = newnode->data + (node->content - node->data);
                 }
         }
 
         if (node->userdata) {
                 newnode->userdata = strdup(node->userdata);
                 switch_assert(newnode->userdata);
         }
 
         if (node->tags) {
                 switch_event_dup(&newnode->tags, node->tags);
         }
 
         if (node->meta) {
                 newnode->meta = cJSON_Duplicate(node->meta, cJSON_True);
         }
 
         return newnode;
 }

◆ switch_log_node_free()

void switch_log_node_free ( switch_log_node_t ** pnode )

Definition at line 300 of file switch_log.c.

References switch_log_node_t::data, switch_log_node_t::meta, switch_event_destroy(), switch_queue_trypush(), switch_safe_free, SWITCH_STATUS_SUCCESS, switch_log_node_t::tags, and switch_log_node_t::userdata.

Referenced by log_thread(), switch_core_memory_reclaim_logger(), and switch_log_meta_vprintf().

 {
         switch_log_node_t *node;
 
         if (!pnode) {
                 return;
         }
 
         node = *pnode;
 
         if (node) {
                 switch_safe_free(node->userdata);
                 switch_safe_free(node->data);
                 if (node->tags) {
                         switch_event_destroy(&node->tags);
                 }
                 if (node->meta) {
                         cJSON_Delete(node->meta);
                         node->meta = NULL;
                 }
 #ifdef SWITCH_LOG_RECYCLE
                 if (switch_queue_trypush(LOG_RECYCLE_QUEUE, node) != SWITCH_STATUS_SUCCESS) {
                         free(node);
                 }
 #else
                 free(node);
 #endif
         }
         *pnode = NULL;
 }

◆ switch_log_node_to_json()

cJSON* switch_log_node_to_json	(	const switch_log_node_t *	node,
		int	log_level,
		switch_log_json_format_t *	json_format,
		switch_event_t *	chan_vars
	)

Convert a log node to JSON object. Destroy JSON object when finished.

Parameters

node	the node
log_level	the log level
json_format	the output format definition
char_vars	optional channel variables to add to logs

Definition at line 91 of file switch_log.c.

 {
         cJSON *json = NULL;
         char *hostname;
         char *full_message = node->content;
         char *parsed_full_message = NULL;
         char *field_name = NULL;
         switch_event_t *log_fields = NULL;
         switch_core_session_t *session = NULL;
 
         if (node->meta && cJSON_IsObject(node->meta)) {
                 if (json_format->custom_field_prefix) {
                         cJSON *field = NULL;
                         json = cJSON_CreateObject();
                         for (field = node->meta->child; field; field = field->next) {
                                 if (!zstr(field->string)) {
                                         char *field_name = switch_mprintf("%s%s", json_format->custom_field_prefix, field->string);
                                         cJSON_AddItemToObject(json, field_name, cJSON_Duplicate(field, cJSON_True));
                                         free(field_name);
                                 }
                         }
                 } else {
                         json = cJSON_Duplicate(node->meta, cJSON_True);
                 }
         } else {
                 json = cJSON_CreateObject();
         }
 
         if (json_format->version.name && json_format->version.value) {
                 cJSON_AddItemToObject(json, json_format->version.name, cJSON_CreateString(json_format->version.value));
         }
         if (json_format->host.name) {
                 if (json_format->host.value) {
                         cJSON_AddItemToObject(json, json_format->host.name, cJSON_CreateString(json_format->host.value));
                 } else if ((hostname = switch_core_get_variable("hostname")) && !zstr(hostname)) {
                         cJSON_AddItemToObject(json, json_format->host.name, cJSON_CreateString(hostname));
                 } else if ((hostname = switch_core_get_variable("local_ip_v4")) && !zstr(hostname)) {
                         cJSON_AddItemToObject(json, json_format->host.name, cJSON_CreateString(hostname));
                 }
         }
         if (json_format->timestamp.name) {
                 double timestamp = node->timestamp;
                 if (json_format->timestamp_divisor > 1.0) {
                         timestamp = timestamp / json_format->timestamp_divisor;
                 }
                 cJSON_AddItemToObject(json, json_format->timestamp.name, cJSON_CreateNumber(timestamp));
         }
         if (json_format->level.name) {
                 cJSON_AddItemToObject(json, json_format->level.name, cJSON_CreateNumber(log_level));
         }
         if (json_format->ident.name) {
                 if (json_format->ident.value) {
                         cJSON_AddItemToObject(json, json_format->ident.name, cJSON_CreateString(json_format->ident.value));
                 } else {
                         cJSON_AddItemToObject(json, json_format->ident.name, cJSON_CreateString("freeswitch"));
                 }
         }
         if (json_format->pid.name) {
                 if (json_format->pid.value) {
                         cJSON_AddItemToObject(json, json_format->pid.name, cJSON_CreateNumber(atoi(json_format->pid.value)));
                 } else {
                         cJSON_AddItemToObject(json, json_format->pid.name, cJSON_CreateNumber((int)getpid()));
                 }
         }
         if (json_format->uuid.name && !zstr(node->userdata)) {
                 cJSON_AddItemToObject(json, json_format->uuid.name, cJSON_CreateString(node->userdata));
         }
         if (json_format->file.name && !zstr_buf(node->file)) {
                 cJSON_AddItemToObject(json, json_format->file.name, cJSON_CreateString(node->file));
                 if (json_format->line.name) {
                         cJSON_AddItemToObject(json, json_format->line.name, cJSON_CreateNumber(node->line));
                 }
         }
         if (json_format->function.name && !zstr_buf(node->func)) {
                 cJSON_AddItemToObject(json, json_format->function.name, cJSON_CreateString(node->func));
         }
         if (json_format->sequence.name) {
                 cJSON_AddItemToObject(json, json_format->sequence.name, cJSON_CreateNumber(node->sequence));
         }
 
         /* skip initial space and new line */
         if (*full_message == ' ') {
                 full_message++;
         }
         if (*full_message == '\n') {
                 full_message++;
         }
 
         /* get fields from log tags */
         if (node->tags) {
                 switch_event_dup(&log_fields, node->tags);
         }
 
         /* get fields from channel data, if configured */
         if (!zstr(node->userdata) && chan_vars && chan_vars->headers && (session = switch_core_session_locate(node->userdata))) {
                 switch_channel_t *channel = switch_core_session_get_channel(session);
                 switch_event_header_t *hp;
                 /* session_fields name mapped to variable name */
                 for (hp = chan_vars->headers; hp; hp = hp->next) {
                         if (!zstr(hp->name) && !zstr(hp->value)) {
                                 const char *val = switch_channel_get_variable(channel, hp->value);
                                 if (!zstr(val)) {
                                         if (!log_fields) {
                                                 switch_event_create_plain(&log_fields, SWITCH_EVENT_CHANNEL_DATA);
                                         }
                                         switch_event_add_header_string(log_fields, SWITCH_STACK_BOTTOM, hp->name, val);
                                 }
                         }
                 }
                 switch_core_session_rwunlock(session);
         }
 
         /* parse list of fields from message text, if any */
         if (strncmp(full_message, "LOG_FIELDS", 10) == 0) {
                 switch_event_create_brackets(full_message+10, '[', ']', ',', &log_fields, &parsed_full_message, SWITCH_TRUE);
                 full_message = parsed_full_message;
         }
 
         /* add additional fields */
         if (log_fields) {
                 switch_event_header_t *hp;
                 const char *prefix = json_format->custom_field_prefix ? json_format->custom_field_prefix : "";
                 for (hp = log_fields->headers; hp; hp = hp->next) {
                         if (!zstr(hp->name) && !zstr(hp->value)) {
                                 if (strncmp(hp->name, "@#", 2) == 0) {
                                         field_name = switch_mprintf("%s%s", prefix, hp->name + 2);
                                         cJSON_AddItemToObject(json, field_name, cJSON_CreateNumber(strtod(hp->value, NULL)));
                                 } else {
                                         field_name = switch_mprintf("%s%s", prefix, hp->name);
                                         cJSON_AddItemToObject(json, field_name, cJSON_CreateString(hp->value));
                                 }
                                 free(field_name);
                         }
                 }
                 switch_event_destroy(&log_fields);
         }
 
         if (json_format->full_message.name) {
                 cJSON_AddItemToObject(json, json_format->full_message.name, cJSON_CreateString(full_message));
         } else {
                 cJSON_AddItemToObject(json, "message", cJSON_CreateString(full_message));
         }
 
         if (json_format->short_message.name) {
                 char short_message[151];
                 char *short_message_end = NULL;
                 switch_snprintf(short_message, sizeof(short_message) - 1, "%s", full_message);
                 if ((short_message_end = strchr(short_message, '\n'))) {
                         *short_message_end = '\0';
                 }
                 cJSON_AddItemToObject(json, json_format->short_message.name, cJSON_CreateString(short_message));
         }
 
         switch_safe_free(parsed_full_message);
 
         return json;
 }

◆ switch_log_printf()

void switch_log_printf	(	_In_ switch_text_channel_t	channel,
		_In_z_ const char *	file,
		_In_z_ const char *	func,
		_In_ int	line,
		_In_opt_z_ const char *	userdata,
		_In_ switch_log_level_t	level,
		_In_z_ _Printf_format_string_ const char *	fmt,
			...
	)

Write log data to the logging engine.

Parameters

channel	the log channel to write to
file	the current file
func	the current function
line	the current line
userdata	ununsed
level	the current log level
fmt	desired format
...	variable args

Note: there are channel macros to supply the first 4 parameters (SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_LOG_CLEAN, ...)

See also: switch_types.h

◆ switch_log_shutdown()

switch_status_t switch_log_shutdown ( void )

Shut down the logging engine.

Note: to be called at application termination by the core

Definition at line 799 of file switch_log.c.

References switch_cond_next(), switch_core_memory_reclaim_logger(), switch_queue_push(), SWITCH_STATUS_SUCCESS, switch_thread_join(), thread, and THREAD_RUNNING.

Referenced by switch_core_destroy().

 {
         switch_status_t st;
 
 
         switch_queue_push(LOG_QUEUE, NULL);
         while (THREAD_RUNNING) {
                 switch_cond_next();
         }
 
         switch_thread_join(&st, thread);
 
         switch_core_memory_reclaim_logger();
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_log_str2level()

switch_log_level_t switch_log_str2level ( _In_z_ const char * str )

Return the level number of the specified log level name.

Parameters

str	the name of the level

Returns: the log level

Referenced by console_log(), console_log2(), CoreSession::consoleLog(), CoreSession::consoleLog2(), fs_consol_log(), and switch_load_core_config().

◆ switch_log_str2mask()

uint32_t switch_log_str2mask ( _In_z_ const char * str )

◆ switch_log_unbind_logger()

switch_status_t switch_log_unbind_logger ( _In_ switch_log_function_t function )

◆ switch_log_vprintf()

void void switch_log_vprintf	(	_In_ switch_text_channel_t	channel,
		_In_z_ const char *	file,
		_In_z_ const char *	func,
		_In_ int	line,
		_In_opt_z_ const char *	userdata,
		_In_ switch_log_level_t	level,
		const char *	fmt,
		va_list	ap
	)

Write log data to the logging engine.

Parameters

channel	the log channel to write to
file	the current file
func	the current function
line	the current line
userdata	ununsed
level	the current log level
fmt	desired format
ap	variable args