switch_log.c File Reference

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

Include dependency graph for switch_log.c:

Go to the source code of this file.

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
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...
static switch_log_node_t *	switch_log_node_alloc (void)
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)
static int	switch_log_to_mask (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_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,...)
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)
void	switch_log_meta_vprintf (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, 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 int64_t	log_sequence = 0
static const char *	COLORS []
static switch_thread_t *	thread

Macro Definition Documentation

do_mods

#define do_mods   (LOG_QUEUE && THREAD_RUNNING)

Definition at line 548 of file switch_log.c.

Referenced by switch_log_meta_vprintf().

Typedef Documentation

switch_log_binding_t

typedef struct switch_log_binding switch_log_binding_t

Definition at line 56 of file switch_log.c.

Function Documentation

log_thread()

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

static

Definition at line 488 of file switch_log.c.

References BINDLOCK, switch_log_binding::function, switch_log_binding::level, switch_log_node_t::level, log_sequence, switch_log_binding::next, switch_log_node_t::sequence, 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);
                node->sequence = ++log_sequence;
                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_log_bind_logger()

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 452 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_log_init()

switch_status_t switch_log_init	(	switch_memory_pool_t *	pool,
		switch_bool_t	colorize
	)

Definition at line 745 of file switch_log.c.

References BINDLOCK, COLORIZE, LOG_POOL, 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;
}

switch_log_level2str()

const char* switch_log_level2str

(

switch_log_level_t

level

)

Definition at line 331 of file switch_log.c.

References LEVELS, and SWITCH_LOG_DEBUG.

Referenced by switch_log_meta_vprintf().

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

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,
			...
	)

Definition at line 529 of file switch_log.c.

References switch_log_meta_vprintf().

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

switch_log_meta_vprintf()

void switch_log_meta_vprintf	(	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,
		va_list	ap
	)

Definition at line 554 of file switch_log.c.

References switch_log_node_t::channel, COLORIZE, COLORS, console_mods_loaded, switch_log_node_t::content, switch_log_node_t::data, switch_runtime::debug_level, do_mods, switch_log_node_t::file, switch_log_node_t::func, switch_runtime::hard_log_level, switch_log_binding::level, switch_log_node_t::level, switch_log_node_t::line, switch_core_session::loglevel, MAX_LEVEL, memset(), switch_log_node_t::meta, runtime, switch_log_node_t::slevel, switch_assert, switch_channel_get_log_tags(), SWITCH_CHANNEL_ID_EVENT, SWITCH_CHANNEL_ID_LOG_CLEAN, SWITCH_CHANNEL_ID_SESSION, switch_core_data_channel(), switch_core_idle_cpu(), switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_cut_path(), switch_event_add_header(), switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_LOG, switch_event_running(), SWITCH_LOG_DISABLE, SWITCH_LOG_INVALID, switch_log_level2str(), switch_log_node_alloc(), switch_log_node_free(), SWITCH_LOG_UNINIT, switch_micro_time_now(), switch_queue_trypush(), switch_safe_free, SWITCH_SEQ_DEFAULT_COLOR, switch_set_string, switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_time_exp_lt(), switch_vasprintf(), switch_log_node_t::tags, switch_log_node_t::timestamp, switch_time_exp_t::tm_hour, switch_time_exp_t::tm_mday, switch_time_exp_t::tm_min, switch_time_exp_t::tm_mon, switch_time_exp_t::tm_sec, switch_time_exp_t::tm_usec, switch_time_exp_t::tm_year, switch_log_node_t::userdata, and zstr.

Referenced by switch_log_meta_printf(), switch_log_printf(), and switch_log_vprintf().

{
        cJSON *log_meta = NULL;
        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 (meta && *meta) {
                log_meta = *meta;
                *meta = NULL;
        }

        if (limit_level == SWITCH_LOG_DISABLE) {
                goto end;
        }

        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) {
                        goto end;
                }

                level = 1;
        }

        if (level > limit_level) {
                goto end;
        }

        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 %0.2f%%%%",
                                                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_usec, switch_core_idle_cpu());

                //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;
                node->tags = NULL;
                node->meta = log_meta;
                log_meta = NULL;
                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;
                        if (session) {
                                switch_channel_get_log_tags(switch_core_session_get_channel(session), &node->tags);
                        }
                } else {
                        node->userdata = !zstr(userdata) ? strdup(userdata) : NULL;
                }

                if (switch_queue_trypush(LOG_QUEUE, node) != SWITCH_STATUS_SUCCESS) {
                        switch_log_node_free(&node);
                }
        }

  end:

        cJSON_Delete(log_meta);
        switch_safe_free(data);
        switch_safe_free(new_fmt);

}

switch_log_node_alloc()

static switch_log_node_t* switch_log_node_alloc ( void  )

static

Definition at line 249 of file switch_log.c.

References switch_assert, switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_log_meta_vprintf(), and switch_log_node_dup().

{
        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;
}

switch_log_printf()

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 538 of file switch_log.c.

References switch_log_meta_vprintf().

Referenced by log_thread(), and switch_core_memory_reclaim_logger().

{
        va_list ap;

        va_start(ap, fmt);
        switch_log_meta_vprintf(channel, file, func, line, userdata, level, NULL, fmt, ap);
        va_end(ap);
}

switch_log_str2level()

switch_log_level_t switch_log_str2level

(

const char *

str

)

Definition at line 393 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 - 1);
                        break;
                }
        }

        return level;
}

switch_log_str2mask()

uint32_t switch_log_str2mask

(

const char *

str

)

Definition at line 363 of file switch_log.c.

References switch_log_binding::level, switch_assert, SWITCH_LOG_INVALID, switch_log_str2level(), switch_log_to_mask(), 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_LOG_INVALID;

        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 |= switch_log_to_mask(level);
                                }
                        }
                }
        }

        free(p);

        return mask;
}

switch_log_to_mask()

static int switch_log_to_mask ( switch_log_level_t  level )

static

Definition at line 339 of file switch_log.c.

References SWITCH_LOG_ALERT, SWITCH_LOG_CONSOLE, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, SWITCH_LOG_NOTICE, and SWITCH_LOG_WARNING.

Referenced by switch_log_str2mask().

{
        switch (level) {
        case SWITCH_LOG_DEBUG:
                return (1<<7);
        case SWITCH_LOG_INFO:
                return (1<<6);
        case SWITCH_LOG_NOTICE:
                return (1<<5);
        case SWITCH_LOG_WARNING:
                return (1<<4);
        case SWITCH_LOG_ERROR:
                return (1<<3);
        case SWITCH_LOG_CRIT:
                return (1<<2);
        case SWITCH_LOG_ALERT:
                return (1<<1);
        case SWITCH_LOG_CONSOLE:
                return (1<<0);
        default:
                return 0;
        }
}

switch_log_unbind_logger()

switch_status_t switch_log_unbind_logger

(

switch_log_function_t

function

)

Definition at line 425 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;
}

switch_log_vprintf()

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 549 of file switch_log.c.

References switch_log_meta_vprintf().

{
        switch_log_meta_vprintf(channel, file, func, line, userdata, level, NULL, fmt, ap);
}

Variable Documentation

BINDINGS

switch_log_binding_t* BINDINGS = NULL

static

Definition at line 59 of file switch_log.c.

BINDLOCK

switch_mutex_t* BINDLOCK = NULL

static

Definition at line 60 of file switch_log.c.

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

COLORIZE

switch_bool_t COLORIZE = SWITCH_FALSE

static

Definition at line 69 of file switch_log.c.

Referenced by switch_log_init(), and switch_log_meta_vprintf().

COLORS

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 86 of file switch_log.c.

Referenced by switch_log_meta_vprintf().

console_mods_loaded

int console_mods_loaded = 0

static

Definition at line 68 of file switch_log.c.

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

LEVELS

const char* LEVELS[]

static

Initial value:

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

Definition at line 36 of file switch_log.c.

Referenced by switch_log_level2str(), and switch_log_str2level().

LOG_POOL

switch_memory_pool_t* LOG_POOL = NULL

static

Definition at line 58 of file switch_log.c.

Referenced by switch_log_bind_logger(), and switch_log_init().

LOG_QUEUE

switch_queue_t* LOG_QUEUE = NULL

static

Definition at line 61 of file switch_log.c.

log_sequence

int64_t log_sequence = 0

static

Definition at line 71 of file switch_log.c.

Referenced by log_thread().

MAX_LEVEL

uint8_t MAX_LEVEL = 0

static

Definition at line 66 of file switch_log.c.

Referenced by switch_log_bind_logger(), and switch_log_meta_vprintf().

mods_loaded

int mods_loaded = 0

static

Definition at line 67 of file switch_log.c.

Referenced by switch_log_bind_logger(), and switch_log_unbind_logger().

thread

switch_thread_t* thread

static

Definition at line 486 of file switch_log.c.

Referenced by check_queue(), launch_collect_thread(), switch_console_save_history(), switch_core_launch_thread(), switch_core_session_launch_thread(), switch_core_session_thread(), switch_core_session_thread_launch(), switch_core_sql_db_thread(), switch_ivr_broadcast_in_thread(), switch_ivr_enterprise_originate(), switch_log_init(), switch_log_shutdown(), switch_system_thread(), switch_xml_free_in_thread(), and task_thread_loop().

THREAD_RUNNING

int8_t THREAD_RUNNING = 0

static

Definition at line 65 of file switch_log.c.

Referenced by log_thread(), switch_log_init(), and switch_log_shutdown().