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 Callback {
    LogFn    fn;        
    void    *user_data; 
    LogLevel min_level; 
} Callback;

typedef struct Logger {
    void     *lock_data;            
    LogLockFn lock_fn;          
    LogLevel  level;            
    b32   quiet;            
    Callback  callbacks[MAX_CALLBACKS]; 
} Logger;

static Logger L = {.level = LOG_LEVEL_TRACE};

static const char *level_strings[] = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
 
// Standard ANSI terminal colors
#if OS_WINDOWS
#   define COLOR_TRACE ""
#   define COLOR_DEBUG ""
#   define COLOR_INFO ""
#   define COLOR_WARN ""
#   define COLOR_ERROR ""
#   define COLOR_FATAL ""
#   define COLOR_RESET ""
#else
#   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"
#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(LogEvent *ev)
{
    char   buf[16];
    time_t t                           = time(NULL);
    buf[strftime(buf, sizeof(buf), "%H:%M:%S", localtime(&t))] = '\0';
 
    // Write to stderr for warnings/errors, stdout for standard info
    FILE *out = (ev->level >= LOG_LEVEL_WARN) ? stderr : stdout;
 
    fprintf(out,
        "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ",
        buf,
        level_colors[ev->level],
        level_strings[ev->level],
        ev->file,
        ev->line);
 
    vfprintf(out, ev->fmt, ev->ap);
    fprintf(out, "\n");
    fflush(out);
}

static void
file_callback(LogEvent *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
log_set_level(LogLevel level)
{
    L.level = level;
}
 
void
log_set_quiet(b32 enable)
{
    L.quiet = enable;
}
 
void
log_set_lock(LogLockFn fn, void *user_data)
{
    L.lock_fn   = fn;
    L.lock_data = user_data;
}
 
b32
log_add_fp(FILE *fp, LogLevel min_level)
{
    return log_add_callback(file_callback, fp, min_level);
}
 
b32
log_add_callback(LogFn fn, void *user_data, LogLevel 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; // No free callback slot
}
 
void
log_message(LogLevel level, const char *file, int line, const char *fmt, ...)
{
    if (level < L.level) {
        return;
    }
 
    LogEvent 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++) {
        Callback *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();
}