base_log.c

Go to the documentation of this file.

 
#include "base/base_log.h"
#include <string.h>
#include <time.h>

#define MAX_CALLBACKS 4

typedef struct BaseLogCallback {
    BaseLogFn    fn;    
    void        *user_data; 
    BaseLogLevel min_level; 
} BaseLogCallback;

typedef struct BaseLogger {
    void           *lock_data; 
    BaseLogLockFn   lock_fn;   
    BaseLogLevel    level;     
    b32     quiet;     
    BaseLogCallback callbacks[MAX_CALLBACKS]; 
} BaseLogger;

static BaseLogger L = {.level = BASE_LOG_LEVEL_TRACE};

static const char *level_strings[] = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
 
// Standard ANSI terminal colors
#define COLOR_TRACE "\x1b[94m"
#define COLOR_DEBUG "\x1b[36m"
#define COLOR_INFO  "\x1b[32m"
#define COLOR_WARN  "\x1b[33m"
#define COLOR_ERROR "\x1b[31m"
#define COLOR_FATAL "\x1b[35m"
#define COLOR_RESET "\x1b[0m"
 
#if OS_WINDOWS
#   include <windows.h>
static b32
enable_vt_colors(HANDLE handle)
{
    DWORD mode = 0;
    if (!GetConsoleMode(handle, &mode)) return 0;
    return SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
}
 
static b32 vt_stdout_enabled = -1;
static b32 vt_stderr_enabled = -1;
 
static const char *
color_for_stream(b32 is_stderr, const char *color)
{
    if (is_stderr) {
        if (vt_stderr_enabled < 0)
            vt_stderr_enabled = enable_vt_colors(GetStdHandle(STD_ERROR_HANDLE));
        return vt_stderr_enabled ? color : "";
    } else {
        if (vt_stdout_enabled < 0)
            vt_stdout_enabled = enable_vt_colors(GetStdHandle(STD_OUTPUT_HANDLE));
        return vt_stdout_enabled ? color : "";
    }
}
#else
static const char *
color_for_stream(b32 is_stderr, const char *color)
{
    (void)is_stderr;
    return color;
}
#endif

static const char *level_colors[] =
    {COLOR_TRACE, COLOR_DEBUG, COLOR_INFO, COLOR_WARN, COLOR_ERROR, COLOR_FATAL};
 
// Internal Helpers

static void
lock(void)
{
    if (L.lock_fn) {
        L.lock_fn(L.lock_data, 1);
    }
}

static void
unlock(void)
{
    if (L.lock_fn) {
        L.lock_fn(L.lock_data, 0);
    }
}

static void
log_stdout(BaseLogEvent *ev)
{
    char   buf[16];
    time_t t                           = time(NULL);
    buf[strftime(buf, sizeof(buf), "%H:%M:%S", localtime(&t))] = '\0';
 
    b32   is_err = (ev->level >= BASE_LOG_LEVEL_WARN);
    FILE *out    = is_err ? stderr : stdout;
 
    fprintf(out,
        "%s %s%-5s%s \x1b[90m%s:%d:\x1b[0m ",
        buf,
        color_for_stream(is_err, level_colors[ev->level]),
        level_strings[ev->level],
        color_for_stream(is_err, COLOR_RESET),
        ev->file,
        ev->line);
 
    vfprintf(out, ev->fmt, ev->ap);
    fprintf(out, "\n");
    fflush(out);
}

static void
file_callback(BaseLogEvent *ev, void *user_data)
{
    FILE  *fp = (FILE *)user_data;
    char   buf[64];
    time_t t                                = time(NULL);
    buf[strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&t))] = '\0';
 
    fprintf(fp, "%s %-5s %s:%d: ", buf, level_strings[ev->level], ev->file, ev->line);
    vfprintf(fp, ev->fmt, ev->ap);
    fprintf(fp, "\n");
    fflush(fp);
}
 
void
base_log_set_level(BaseLogLevel level)
{
    L.level = level;
}
 
void
base_log_set_quiet(b32 enable)
{
    L.quiet = enable;
}
 
void
base_log_set_lock(BaseLogLockFn fn, void *user_data)
{
    L.lock_fn   = fn;
    L.lock_data = user_data;
}
 
b32
base_log_add_fp(FILE *fp, BaseLogLevel min_level)
{
    return base_log_add_callback(file_callback, fp, min_level);
}
 
b32
base_log_add_callback(BaseLogFn fn, void *user_data, BaseLogLevel min_level)
{
    for (int i = 0; i < MAX_CALLBACKS; i++) {
        if (L.callbacks[i].fn == NULL) {
            L.callbacks[i].fn    = fn;
            L.callbacks[i].user_data = user_data;
            L.callbacks[i].min_level = min_level;
            return 1;
        }
    }
    return 0;
}
 
b32
base_log_remove_callback(BaseLogFn fn)
{
    for (int i = 0; i < MAX_CALLBACKS; i++) {
        if (L.callbacks[i].fn == fn) {
            L.callbacks[i].fn    = NULL;
            L.callbacks[i].user_data = NULL;
            L.callbacks[i].min_level = 0;
            return 1;
        }
    }
    return 0;
}
 
void
base_log_message(BaseLogLevel level, const char *file, int line, const char *fmt, ...)
{
    if (level < L.level) {
        return;
    }
 
    BaseLogEvent ev = {
        .fmt   = fmt,
        .file  = file,
        .line  = line,
        .level = level,
    };
 
    lock();
 
    if (!L.quiet) {
        va_start(ev.ap, fmt);
        log_stdout(&ev);
        va_end(ev.ap);
    }
 
    for (int i = 0; i < MAX_CALLBACKS; i++) {
        BaseLogCallback *cb = &L.callbacks[i];
        if (cb->fn != NULL && level >= cb->min_level) {
            va_start(ev.ap, fmt);
            cb->fn(&ev, cb->user_data);
            va_end(ev.ap);
        }
    }
 
    unlock();
}