#include <switch.h>
#include "private/switch_core_pvt.h"

Include dependency graph for switch_log.c:

Data Structures
struct	switch_log_binding

Macros
#define	do_mods (LOG_QUEUE && THREAD_RUNNING)

Typedefs
typedef struct switch_log_binding	switch_log_binding_t

Functions
static switch_log_node_t *	switch_log_node_alloc ()

switch_log_node_t *	switch_log_node_dup (const switch_log_node_t *node)

void	switch_log_node_free (switch_log_node_t **pnode)

const char *	switch_log_level2str (switch_log_level_t level)

uint32_t	switch_log_str2mask (const char *str)

switch_log_level_t	switch_log_str2level (const char *str)

switch_status_t	switch_log_unbind_logger (switch_log_function_t function)

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

static void *SWITCH_THREAD_FUNC	log_thread (switch_thread_t t, void obj)

void	switch_log_printf (switch_text_channel_t channel, const char file, const char func, int line, const char userdata, switch_log_level_t level, const char fmt,...)

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

switch_status_t	switch_log_init (switch_memory_pool_t *pool, switch_bool_t colorize)

void	switch_core_memory_reclaim_logger (void)

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

Variables
static const char *	LEVELS []

static switch_memory_pool_t *	LOG_POOL = NULL

static switch_log_binding_t *	BINDINGS = NULL

static switch_mutex_t *	BINDLOCK = NULL

static switch_queue_t *	LOG_QUEUE = NULL

static int8_t	THREAD_RUNNING = 0

static uint8_t	MAX_LEVEL = 0

static int	mods_loaded = 0

static int	console_mods_loaded = 0

static switch_bool_t	COLORIZE = SWITCH_FALSE

static const char *	COLORS []

static switch_thread_t *	thread

Macro Definition Documentation

#define do_mods (LOG_QUEUE && THREAD_RUNNING)

Definition at line 331 of file switch_log.c.

Referenced by switch_log_vprintf().

Typedef Documentation

typedef struct switch_log_binding switch_log_binding_t

Definition at line 55 of file switch_log.c.

Function Documentation

static void* SWITCH_THREAD_FUNC log_thread	(	switch_thread_t *	t,
		void *	obj
	)

static

Definition at line 281 of file switch_log.c.

References BINDLOCK, switch_log_binding::function, switch_log_binding::level, switch_log_node_t::level, LOG_QUEUE, switch_log_binding::next, SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, switch_log_node_free(), switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_pop(), SWITCH_STATUS_SUCCESS, and THREAD_RUNNING.

Referenced by switch_log_init().

 {
 
         if (!obj) {
                 obj = NULL;
         }
         THREAD_RUNNING = 1;
 
         while (THREAD_RUNNING == 1) {
                 void *pop = NULL;
                 switch_log_node_t *node = NULL;
                 switch_log_binding_t *binding;
 
                 if (switch_queue_pop(LOG_QUEUE, &pop) != SWITCH_STATUS_SUCCESS) {
                         break;
                 }
 
                 if (!pop) {
                         THREAD_RUNNING = -1;
                         break;
                 }
 
                 node = (switch_log_node_t *) pop;
                 switch_mutex_lock(BINDLOCK);
                 for (binding = BINDINGS; binding; binding = binding->next) {
                         if (binding->level >= node->level) {
                                 binding->function(node, node->level);
                         }
                 }
                 switch_mutex_unlock(BINDLOCK);
 
                 switch_log_node_free(&node);
 
         }
 
         THREAD_RUNNING = 0;
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Logger Ended.\n");
         return NULL;
 }

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

Definition at line 245 of file switch_log.c.

References BINDLOCK, console_mods_loaded, switch_log_binding::function, switch_log_binding::is_console, switch_log_binding::level, LOG_POOL, MAX_LEVEL, mods_loaded, switch_log_binding::next, switch_assert, switch_core_alloc, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

 {
         switch_log_binding_t *binding = NULL, *ptr = NULL;
         switch_assert(function != NULL);
 
         if (!(binding = switch_core_alloc(LOG_POOL, sizeof(*binding)))) {
                 return SWITCH_STATUS_MEMERR;
         }
 
         if ((uint8_t) level > MAX_LEVEL) {
                 MAX_LEVEL = level;
         }
 
         binding->function = function;
         binding->level = level;
         binding->is_console = is_console;
 
         switch_mutex_lock(BINDLOCK);
         for (ptr = BINDINGS; ptr && ptr->next; ptr = ptr->next);
 
         if (ptr) {
                 ptr->next = binding;
         } else {
                 BINDINGS = binding;
         }
         if (is_console) {
                 console_mods_loaded++;
         }
         mods_loaded++;
         switch_mutex_unlock(BINDLOCK);
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_log_init	(	switch_memory_pool_t *	pool,
		switch_bool_t	colorize
	)

Definition at line 506 of file switch_log.c.

References BINDLOCK, COLORIZE, LOG_POOL, LOG_QUEUE, log_thread(), pool, switch_assert, switch_cond_next(), switch_core_get_console(), SWITCH_CORE_QUEUE_LEN, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), SWITCH_TRUE, thread, and THREAD_RUNNING.

 {
         switch_threadattr_t *thd_attr;;
 
         switch_assert(pool != NULL);
 
         LOG_POOL = pool;
 
         switch_threadattr_create(&thd_attr, LOG_POOL);
 
         switch_queue_create(&LOG_QUEUE, SWITCH_CORE_QUEUE_LEN, LOG_POOL);
 #ifdef SWITCH_LOG_RECYCLE
         switch_queue_create(&LOG_RECYCLE_QUEUE, SWITCH_CORE_QUEUE_LEN, LOG_POOL);
 #endif
         switch_mutex_init(&BINDLOCK, SWITCH_MUTEX_NESTED, LOG_POOL);
         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
         switch_thread_create(&thread, thd_attr, log_thread, NULL, LOG_POOL);
 
         while (!THREAD_RUNNING) {
                 switch_cond_next();
         }
 
         if (colorize) {
 #ifdef WIN32
                 hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
                 if (switch_core_get_console() == stdout && hStdout != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(hStdout, &csbiInfo)) {
                         wOldColorAttrs = csbiInfo.wAttributes;
                         COLORIZE = SWITCH_TRUE;
                 }
 #else
                 COLORIZE = SWITCH_TRUE;
 #endif
         }
 
 
         return SWITCH_STATUS_SUCCESS;
 }

const char* switch_log_level2str ( switch_log_level_t level )

Definition at line 149 of file switch_log.c.

References switch_log_binding::level, LEVELS, and SWITCH_LOG_DEBUG.

Referenced by switch_log_vprintf().

 {
         if (level > SWITCH_LOG_DEBUG) {
                 level = SWITCH_LOG_DEBUG;
         }
         return LEVELS[level];
 }

static switch_log_node_t* switch_log_node_alloc ( )

static

Definition at line 88 of file switch_log.c.

References switch_assert, switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_log_node_dup(), and switch_log_vprintf().

 {
         switch_log_node_t *node = NULL;
 #ifdef SWITCH_LOG_RECYCLE
         void *pop = NULL;
 
         if (switch_queue_trypop(LOG_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) {
                 node = (switch_log_node_t *) pop;
         } else {
 #endif
                 node = malloc(sizeof(*node));
                 switch_assert(node);
 #ifdef SWITCH_LOG_RECYCLE
         }
 #endif
         return node;
 }

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

Definition at line 321 of file switch_log.c.

References switch_log_vprintf().

Referenced by log_thread(), and switch_core_memory_reclaim_logger().

 {
         va_list ap;
 
         va_start(ap, fmt);
         switch_log_vprintf(channel, file, func, line, userdata, level, fmt, ap);
         va_end(ap);
 }

switch_log_level_t switch_log_str2level ( const char * str )

Definition at line 186 of file switch_log.c.

References switch_log_binding::level, LEVELS, switch_is_number(), and SWITCH_LOG_INVALID.

Referenced by switch_log_str2mask().

 {
         int x = 0;
         switch_log_level_t level = SWITCH_LOG_INVALID;
 
         if (switch_is_number(str)) {
                 x = atoi(str);
 
                 if (x > SWITCH_LOG_INVALID) {
                         return SWITCH_LOG_INVALID - 1;
                 } else if (x < 0) {
                         return 0;
                 } else {
                         return x;
                 }
         }
 
 
         for (x = 0;; x++) {
                 if (!LEVELS[x]) {
                         break;
                 }
 
                 if (!strcasecmp(LEVELS[x], str)) {
                         level = (switch_log_level_t) x;
                         break;
                 }
         }
 
         return level;
 }

uint32_t switch_log_str2mask ( const char * str )

Definition at line 157 of file switch_log.c.

References switch_log_binding::level, switch_assert, SWITCH_LOG_INVALID, switch_log_str2level(), and switch_separate_string().

 {
         int argc = 0, x = 0;
         char *argv[10] = { 0 };
         uint32_t mask = 0;
         char *p = strdup(str);
         switch_log_level_t level;
 
         switch_assert(p);
 
         if ((argc = switch_separate_string(p, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                 for (x = 0; x < argc && argv[x]; x++) {
                         if (!strcasecmp(argv[x], "all")) {
                                 mask = 0xFF;
                                 break;
                         } else {
                                 level = switch_log_str2level(argv[x]);
                                 if (level != SWITCH_LOG_INVALID) {
                                         mask |= (1 << level);
                                 }
                         }
                 }
         }
 
         free(p);
 
         return mask;
 }

switch_status_t switch_log_unbind_logger ( switch_log_function_t function )

Definition at line 218 of file switch_log.c.

References BINDLOCK, console_mods_loaded, switch_log_binding::function, switch_log_binding::is_console, mods_loaded, switch_log_binding::next, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_log_binding_t *ptr = NULL, *last = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_mutex_lock(BINDLOCK);
         for (ptr = BINDINGS; ptr; ptr = ptr->next) {
                 if (ptr->function == function) {
                         if (last) {
                                 last->next = ptr->next;
                         } else {
                                 BINDINGS = ptr->next;
                         }
                         status = SWITCH_STATUS_SUCCESS;
                         mods_loaded--;
                         if (ptr->is_console) {
                                 console_mods_loaded--;
                         }
                         break;
                 }
                 last = ptr;
         }
         switch_mutex_unlock(BINDLOCK);
 
         return status;
 }

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

Definition at line 332 of file switch_log.c.

Referenced by switch_log_printf().

 {
         char *data = NULL;
         char *new_fmt = NULL;
         int ret = 0;
         FILE *handle;
         const char *filep = (file ? switch_cut_path(file) : "");
         const char *funcp = (func ? func : "");
         char *content = NULL;
         switch_time_t now = switch_micro_time_now();
         uint32_t len;
 #ifdef SWITCH_FUNC_IN_LOG
         const char *extra_fmt = "%s [%s] %s:%d %s()%c%s";
 #else
         const char *extra_fmt = "%s [%s] %s:%d%c%s";
 #endif
         switch_log_level_t limit_level = runtime.hard_log_level;
         switch_log_level_t special_level = SWITCH_LOG_UNINIT;
 
         if (channel == SWITCH_CHANNEL_ID_SESSION && userdata) {
                 switch_core_session_t *session = (switch_core_session_t *) userdata;
                 special_level = session->loglevel;
                 if (limit_level < session->loglevel) {
                         limit_level = session->loglevel;
                 }
         }
 
         if (level > 100) {
                 if ((uint32_t) (level - 100) > runtime.debug_level) {
                         return;
                 }
 
                 level = 1;
         }
 
         if (level > limit_level) {
                 return;
         }
 
         switch_assert(level < SWITCH_LOG_INVALID);
 
         handle = switch_core_data_channel(channel);
 
         if (channel != SWITCH_CHANNEL_ID_LOG_CLEAN) {
                 char date[80] = "";
                 //switch_size_t retsize;
                 switch_time_exp_t tm;
 
                 switch_time_exp_lt(&tm, now);
                 switch_snprintf(date, sizeof(date), "%0.4d-%0.2d-%0.2d %0.2d:%0.2d:%0.2d.%0.6d",
                                                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_usec);
 
                 //switch_strftime_nocheck(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm);
 
 #ifdef SWITCH_FUNC_IN_LOG
                 len = (uint32_t) (strlen(extra_fmt) + strlen(date) + strlen(filep) + 32 + strlen(funcp) + strlen(fmt));
 #else
                 len = (uint32_t) (strlen(extra_fmt) + strlen(date) + strlen(filep) + 32 + strlen(fmt));
 #endif
                 new_fmt = malloc(len + 1);
                 switch_assert(new_fmt);
 #ifdef SWITCH_FUNC_IN_LOG
                 switch_snprintf(new_fmt, len, extra_fmt, date, switch_log_level2str(level), filep, line, funcp, 128, fmt);
 #else
                 switch_snprintf(new_fmt, len, extra_fmt, date, switch_log_level2str(level), filep, line, 128, fmt);
 #endif
 
                 fmt = new_fmt;
         }
 
         ret = switch_vasprintf(&data, fmt, ap);
 
         if (ret == -1) {
                 fprintf(stderr, "Memory Error\n");
                 goto end;
         }
 
         if (channel == SWITCH_CHANNEL_ID_LOG_CLEAN) {
                 content = data;
         } else {
                 if ((content = strchr(data, 128))) {
                         *content = ' ';
                 }
         }
 
         if (channel == SWITCH_CHANNEL_ID_EVENT) {
                 switch_event_t *event;
                 if (switch_event_running() == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_LOG) == SWITCH_STATUS_SUCCESS) {
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-Data", data);
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-File", filep);
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-Function", funcp);
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Line", "%d", line);
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Level", "%d", (int) level);
                         if (!zstr(userdata)) {
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "User-Data", userdata);
                         }
                         switch_event_fire(&event);
                         data = NULL;
                 }
 
                 goto end;
         }
 
         if (console_mods_loaded == 0 || !do_mods) {
                 if (handle) {
                         int aok = 1;
 #ifndef WIN32
 
                         fd_set can_write;
                         int fd;
                         struct timeval to;
 
                         fd = fileno(handle);
                         memset(&to, 0, sizeof(to));
                         FD_ZERO(&can_write);
                         FD_SET(fd, &can_write);
                         to.tv_sec = 0;
                         to.tv_usec = 100000;
                         if (select(fd + 1, NULL, &can_write, NULL, &to) > 0) {
                                 aok = FD_ISSET(fd, &can_write);
                         } else {
                                 aok = 0;
                         }
 #endif
                         if (aok) {
                                 if (COLORIZE) {
 
 #ifdef WIN32
                                         SetConsoleTextAttribute(hStdout, COLORS[level]);
                                         WriteFile(hStdout, data, (DWORD) strlen(data), NULL, NULL);
                                         SetConsoleTextAttribute(hStdout, wOldColorAttrs);
 #else
                                         fprintf(handle, "%s%s%s", COLORS[level], data, SWITCH_SEQ_DEFAULT_COLOR);
 #endif
                                 } else {
                                         fprintf(handle, "%s", data);
                                 }
                         }
                 }
         }
 
         if (do_mods && level <= MAX_LEVEL) {
                 switch_log_node_t *node = switch_log_node_alloc();
 
                 node->data = data;
                 data = NULL;
                 switch_set_string(node->file, filep);
                 switch_set_string(node->func, funcp);
                 node->line = line;
                 node->level = level;
                 node->slevel = special_level;
                 node->content = content;
                 node->timestamp = now;
                 node->channel = channel;
                 if (channel == SWITCH_CHANNEL_ID_SESSION) {
                         switch_core_session_t *session = (switch_core_session_t *) userdata;
                         node->userdata = userdata ? strdup(switch_core_session_get_uuid(session)) : NULL;
                 } else {
                         node->userdata = !zstr(userdata) ? strdup(userdata) : NULL;
                 }
 
                 if (switch_queue_trypush(LOG_QUEUE, node) != SWITCH_STATUS_SUCCESS) {
                         switch_log_node_free(&node);
                 }
         }
 
   end:
 
         switch_safe_free(data);
         switch_safe_free(new_fmt);
 
 }

Variable Documentation

switch_log_binding_t* BINDINGS = NULL

static

Definition at line 58 of file switch_log.c.

switch_mutex_t* BINDLOCK = NULL

static

Definition at line 59 of file switch_log.c.

Referenced by log_thread(), switch_log_bind_logger(), switch_log_init(), and switch_log_unbind_logger().

switch_bool_t COLORIZE = SWITCH_FALSE

static

Definition at line 68 of file switch_log.c.

Referenced by switch_log_init(), and switch_log_vprintf().

const char* COLORS[]

static

Initial value:

=
        { SWITCH_SEQ_DEFAULT_COLOR, SWITCH_SEQ_FRED, SWITCH_SEQ_FRED, SWITCH_SEQ_FRED, SWITCH_SEQ_FMAGEN, SWITCH_SEQ_FCYAN, SWITCH_SEQ_FGREEN,
SWITCH_SEQ_FYELLOW }

Definition at line 83 of file switch_log.c.

Referenced by switch_log_vprintf().

int console_mods_loaded = 0

static

Definition at line 67 of file switch_log.c.

Referenced by switch_log_bind_logger(), switch_log_unbind_logger(), and switch_log_vprintf().

const char* LEVELS[]

static

Initial value:

= {
        "CONSOLE",
        "ALERT",
        "CRIT",
        "ERR",
        "WARNING",
        "NOTICE",
        "INFO",
        "DEBUG",
        NULL
}