pico_log.h

Go to the documentation of this file.

 
#ifndef PICO_LOG_H
#define PICO_LOG_H
 
#include <stdarg.h>  // ...
#include <stdbool.h> // bool, true, false
#include <stddef.h>  // NULL
#include <stdio.h>   // FILE
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum
{
    LOG_LEVEL_TRACE = 0,
    LOG_LEVEL_DEBUG,
    LOG_LEVEL_INFO,
    LOG_LEVEL_WARN,
    LOG_LEVEL_ERROR,
    LOG_LEVEL_FATAL,
    LOG_LEVEL_COUNT
} log_level_t;
 
typedef void (*log_appender_fn)(const char* entry, void* udata);
 
typedef void (*log_appender_lock_fn)(bool lock, void *udata);
 
typedef int log_appender_t;
 
bool log_str_to_level(const char* str, log_level_t* level);
 
void log_enable(void);
 
void log_disable(void);
 
log_appender_t log_add_appender(log_appender_fn appender_fp,
                                log_level_t level,
                                void* udata);
 
log_appender_t log_add_stream(FILE* stream, log_level_t level);
 
void log_remove_appender(log_appender_t id);
 
void log_enable_appender(log_appender_t id);
 
void log_disable_appender(log_appender_t id);
 
void log_set_lock(log_appender_t id, log_appender_lock_fn lock_fp, void* udata);
 
void log_set_level(log_appender_t id, log_level_t level);
 
void log_set_time_fmt(log_appender_t id, const char* fmt);
 
void log_display_colors(log_appender_t id, bool enabled);
 
void log_display_timestamp(log_appender_t id, bool enabled);
 
void log_display_level(log_appender_t id, bool enabled);
 
void log_display_file(log_appender_t id, bool enabled);
 
void log_display_function(log_appender_t id, bool enabled);
 
#define log_trace(...) \
        log_write(LOG_LEVEL_TRACE, __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define log_debug(...) \
        log_write(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define log_info(...) \
        log_write(LOG_LEVEL_INFO,  __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define log_warn(...) \
        log_write(LOG_LEVEL_WARN,  __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define log_error(...) \
        log_write(LOG_LEVEL_ERROR, __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define log_fatal(...) \
        log_write(LOG_LEVEL_FATAL, __FILE__, __LINE__, __func__, __VA_ARGS__)
 
 
#if defined(__GNUC__) || defined(__clang__)
__attribute__((format(printf, 5, 6)))
#endif
void log_write(log_level_t level,
               const char* file,
               unsigned line,
               const char* func,
               const char* fmt, ...);
 
 
#ifdef __cplusplus
}
#endif
 
#endif // PICO_LOG_H
 
#ifdef PICO_LOG_IMPLEMENTATION
 
#include <time.h>
#include <string.h>
 
/*
 * Configuration constants/macros.
 */
#ifndef PICO_LOG_MAX_APPENDERS
#define PICO_LOG_MAX_APPENDERS 16
#endif
 
#ifndef PICO_LOG_MAX_MSG_LENGTH
#define PICO_LOG_MAX_MSG_LENGTH 1024
#endif
 
#ifdef NDEBUG
    #define PICO_LOG_ASSERT(expr) ((void)0)
#else
    #ifndef PICO_LOG_ASSERT
        #include <assert.h>
        #define PICO_LOG_ASSERT(expr) assert(expr)
    #endif
#endif
 
/*
 * Internal aliases
 */
 
#define LOG_MAX_APPENDERS  PICO_LOG_MAX_APPENDERS
#define LOG_MAX_MSG_LENGTH PICO_LOG_MAX_MSG_LENGTH
#define LOG_ASSERT         PICO_LOG_ASSERT
 
/*
 * Log entry component maximum sizes. These have been chosen to be overly
 * generous powers of 2 for the sake of safety and simplicity.
 */
 
#define LOG_TIMESTAMP_LEN 64
#define LOG_LEVEL_LEN     32
#define LOG_FILE_LEN      512
#define LOG_FUNC_LEN      32
#define LOG_MSG_LEN       LOG_MAX_MSG_LENGTH
#define LOG_BREAK_LEN     1
 
#define LOG_ENTRY_LEN (LOG_TIMESTAMP_LEN  + \
                       LOG_LEVEL_LEN      + \
                       LOG_FILE_LEN       + \
                       LOG_FUNC_LEN       + \
                       LOG_MSG_LEN        + \
                       LOG_BREAK_LEN)
 
#define LOG_TIME_FMT_LEN 32
#define LOG_TIME_FMT     "%d/%m/%Y %H:%M:%S"
 
#define LOG_TERM_CODE  0x1B
#define LOG_TERM_RESET "[0m"
#define LOG_TERM_GRAY  "[90m"
 
static bool log_initialized    = false; // True if logger is initialized
static bool log_enabled        = true;  // True if logger is enabled
static int  log_appender_count = 0;     // Number of appenders
 
/*
 * Logger level strings indexed by level ID (log_level_t).
 */
static const char* const log_level_str[] =
{
    "TRACE",
    "DEBUG",
    "INFO",
    "WARN",
    "ERROR",
    "FATAL",
    0
};
 
/*
 * Logger level strings indexed by level ID (log_level_t).
 */
static const char* const log_level_str_formatted[] =
{
    "TRACE",
    "DEBUG",
    "INFO ",
    "WARN ",
    "ERROR",
    "FATAL",
    0
};
 
// Appropriated from https://github.com/rxi/log.c (MIT licensed)
static const char* log_level_color[] =
{
    "[94m", "[36m", "[32m", "[33m", "[31m", "[35m", NULL
};
 
/*
 * Appender pointer and metadata.
 */
typedef struct
{
    log_appender_fn      appender_fp;
    void*                udata;
    log_appender_lock_fn lock_fp;
    void*                lock_udata;
    bool                 enabled;
    log_level_t          log_level;
    char                 time_fmt[LOG_TIME_FMT_LEN];
    bool                 colors;
    bool                 timestamp;
    bool                 level;
    bool                 file;
    bool                 func;
} log_appender_data_t;
 
/*
 * Array of appenders.
 */
static log_appender_data_t log_appenders[LOG_MAX_APPENDERS];
 
/*
 * Initializes the logger provided it has not been initialized.
 */
static void
log_try_init (void)
{
    if (log_initialized)
    {
        return;
    }
 
    for (int i = 0; i < LOG_MAX_APPENDERS; i++)
    {
        log_appenders[i].appender_fp = NULL;
    }
 
    log_initialized = true;
}
 
static bool log_appender_exists(log_appender_t id)
{
    log_try_init();
 
    return (id < LOG_MAX_APPENDERS && NULL != log_appenders[id].appender_fp);
}
 
static bool log_appender_enabled(log_appender_t id)
{
    log_try_init();
 
    return log_appender_exists(id) && log_appenders[id].enabled;
}
 
bool log_str_to_level(const char* str, log_level_t* level)
{
    if (!level)
        return false;
 
    for (int i = 0; log_level_str[i]; i++)
    {
        if (0 == strcmp(str, log_level_str[i]))
        {
            *level = (log_level_t)i;
            return true;
        }
    }
 
    return false;
}
 
void
log_enable (void)
{
    log_enabled = true;
}
 
void
log_disable (void)
{
    log_enabled = false;
}
 
log_appender_t
log_add_appender (log_appender_fn appender_fp, log_level_t level, void* udata)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Check if there is space for a new appender.
    LOG_ASSERT(log_appender_count < LOG_MAX_APPENDERS);
 
    // Ensure level is valid
    LOG_ASSERT(level >= 0 && level < LOG_LEVEL_COUNT);
 
    // Iterate through appender array and find an empty slot.
    for (int i = 0; i < LOG_MAX_APPENDERS; i++)
    {
        if (NULL == log_appenders[i].appender_fp)
        {
            log_appender_data_t* appender = &log_appenders[i];
 
            // Store and enable appender
            appender->appender_fp = appender_fp;
            appender->log_level   = level;
            appender->udata       = udata;
            appender->level       = LOG_LEVEL_INFO;
            appender->enabled     = true;
            appender->colors      = false;
            appender->level       = true;
            appender->timestamp   = false;
            appender->file        = false;
            appender->func        = false;
            appender->lock_fp     = NULL;
            appender->lock_udata  = NULL;
 
            strncpy(appender->time_fmt, LOG_TIME_FMT, LOG_TIME_FMT_LEN);
 
            log_appender_count++;
 
            return (log_appender_t)i;
        }
    }
 
    // This should never happen
    LOG_ASSERT(false);
    return 0;
}
 
static void
log_stream_appender (const char* entry, void* udata)
{
    FILE* stream = (FILE*)udata;
    fprintf(stream, "%s", entry);
    fflush(stream);
}
 
log_appender_t
log_add_stream (FILE* stream, log_level_t level)
{
    // Stream must not be NULL
    LOG_ASSERT(NULL != stream);
 
    return log_add_appender(log_stream_appender, level, stream);
}
 
void
log_remove_appender (log_appender_t id)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Reset appender with given ID
    log_appenders[id].appender_fp = NULL;
 
    log_appender_count--;
}
 
void
log_enable_appender (log_appender_t id)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Enable appender
    log_appenders[id].enabled = true;
}
 
void
log_disable_appender (log_appender_t id)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Disable appender
    log_appenders[id].enabled = false;
}
 
void
log_set_lock (log_appender_t id, log_appender_lock_fn lock_fp, void* udata)
{
    // Ensure lock function is initialized
    LOG_ASSERT(NULL != lock_fp);
 
    // Ensure appender is registered
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    log_appenders[id].lock_fp = lock_fp;
    log_appenders[id].lock_udata = udata;
}
 
void
log_set_level (log_appender_t id, log_level_t level)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Ensure level is valid
    LOG_ASSERT(level >= 0 && level < LOG_LEVEL_COUNT);
 
    // Set the level
    log_appenders[id].log_level = level;
}
 
void
log_set_time_fmt (log_appender_t id, const char* fmt)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Copy the time string
    strncpy(log_appenders[id].time_fmt, fmt, LOG_TIME_FMT_LEN);
}
 
void
log_display_colors (log_appender_t id, bool enabled)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Disable appender
    log_appenders[id].colors = enabled;
}
 
void
log_display_timestamp (log_appender_t id, bool enabled)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Turn timestamp on
    log_appenders[id].timestamp = enabled;
}
 
void
log_display_level (log_appender_t id, bool enabled)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Turn level reporting on
    log_appenders[id].level = enabled;
}
 
void
log_display_file (log_appender_t id, bool enabled)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Turn file reporting on
    log_appenders[id].file = enabled;
}
 
void
log_display_function (log_appender_t id, bool enabled)
{
    // Initialize logger if neccesary
    log_try_init();
 
    // Ensure appender is registered
    LOG_ASSERT(log_appender_exists(id));
 
    // Turn file reporting on
    log_appenders[id].func = enabled;
}
 
/*
 * Formats the current time as as string.
 */
static char*
log_time_str (const char* time_fmt, char* str, size_t len)
{
    time_t now = time(0);
    size_t ret = strftime(str, len, time_fmt, localtime(&now));
 
    LOG_ASSERT(ret > 0);
 
    return str;
}
 
static void
log_append_timestamp (char* entry_str, const char* time_fmt)
{
    char time_str[LOG_TIMESTAMP_LEN + 1];
    char tmp_str[LOG_TIMESTAMP_LEN];
 
    snprintf(time_str, sizeof(time_str), "%s ",
             log_time_str(time_fmt, tmp_str, sizeof(tmp_str)));
 
    strncat(entry_str, time_str, LOG_TIMESTAMP_LEN);
}
 
static void
log_append_level (char* entry_str, log_level_t level, bool colors)
{
    char level_str[LOG_LEVEL_LEN];
 
    if (colors)
    {
        snprintf(level_str, sizeof(level_str), "%c%s%s %c%s",
        LOG_TERM_CODE, log_level_color[level],
        log_level_str_formatted[level],
        LOG_TERM_CODE, LOG_TERM_RESET);
    }
    else
    {
        snprintf(level_str, sizeof(level_str), "%s ", log_level_str_formatted[level]);
    }
 
    strncat(entry_str, level_str, LOG_LEVEL_LEN);
}
 
static void
log_append_file (char* entry_str, const char* file, unsigned line)
{
    char file_str[LOG_FILE_LEN];
    snprintf(file_str, sizeof(file_str), "[%s:%u] ", file, line);
    strncat(entry_str, file_str, LOG_FILE_LEN);
}
 
static void
log_append_func (char* entry_str, const char* func, bool colors)
{
   char func_str[LOG_FUNC_LEN];
 
    if (colors)
    {
        snprintf(func_str, sizeof(func_str), "%c%s[%s] %c%s",
                 LOG_TERM_CODE, LOG_TERM_GRAY,
                 func,
                 LOG_TERM_CODE, LOG_TERM_RESET);
    }
    else
    {
        snprintf(func_str, sizeof(func_str), "[%s] ", func);
    }
 
    strncat(entry_str, func_str, LOG_FUNC_LEN);
}
 
void
log_write (log_level_t level, const char* file, unsigned line,
                              const char* func, const char* fmt, ...)
{
    // Ensure logger is initialized
    log_try_init();
 
    // Only write entry if there are registered appenders and the logger is
    // enabled
    if (0 == log_appender_count || !log_enabled)
    {
        return;
    }
 
    // Ensure valid log level
    LOG_ASSERT(level < LOG_LEVEL_COUNT);
 
    for (log_appender_t i = 0; i < LOG_MAX_APPENDERS; i++)
    {
        log_appender_data_t* appender = &log_appenders[i];
 
        if (!log_appender_enabled(i))
            continue;
 
        if (log_appenders[i].log_level <= level)
        {
            char entry_str[LOG_ENTRY_LEN + 1]; // Ensure there is space for
                                              // null char
 
            entry_str[0] = '\0'; // Ensure the entry is null terminated
 
            // Append a timestamp
            if (appender->timestamp)
            {
                log_append_timestamp(entry_str, appender->time_fmt);
            }
 
            // Append the logger level
            if (appender->level)
            {
                log_append_level(entry_str, level, appender->colors);
            }
 
            // Append the filename/line number
            if (appender->file)
            {
                log_append_file(entry_str, file, line);
            }
 
            // Append the function name
            if (appender->func)
            {
                log_append_func(entry_str, func, appender->colors);
            }
 
            // Append the log message
            char msg_str[LOG_MSG_LEN];
 
            va_list args;
            va_start(args, fmt);
            vsnprintf(msg_str, sizeof(msg_str), fmt, args);
            va_end(args);
 
            strncat(entry_str, msg_str, LOG_MSG_LEN);
            strcat(entry_str, "\n");
 
            // Locks the appender
            if (NULL != appender->lock_fp)
            {
                appender->lock_fp(true, appender->lock_udata);
            }
 
            appender->appender_fp(entry_str, appender->udata);
 
            // Unlocks the appender
            if (NULL != appender->lock_fp)
            {
                appender->lock_fp(false, appender->lock_udata);
            }
        }
    }
}
 
#endif // PICO_LOG_IMPLEMENTATION
 
 
/*
    ----------------------------------------------------------------------------
    This software is available under two licenses (A) or (B). You may choose
    either one as you wish:
    ----------------------------------------------------------------------------
 
    (A) The zlib License
 
    Copyright (c) 2021 James McLean
 
    This software is provided 'as-is', without any express or implied warranty.
    In no event will the authors be held liable for any damages arising from the
    use of this software.
 
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
 
    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software in a
    product, an acknowledgment in the product documentation would be appreciated
    but is not required.
 
    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.
 
    3. This notice may not be removed or altered from any source distribution.
 
    ----------------------------------------------------------------------------
 
    (B) Public Domain (www.unlicense.org)
 
    This is free and unencumbered software released into the public domain.
 
    Anyone is free to copy, modify, publish, use, compile, sell, or distribute
    this software, either in source code form or as a compiled binary, for any
    purpose, commercial or non-commercial, and by any means.
 
    In jurisdictions that recognize copyright laws, the author or authors of
    this software dedicate any and all copyright interest in the software to the
    public domain. We make this dedication for the benefit of the public at
    large and to the detriment of our heirs and successors. We intend this
    dedication to be an overt act of relinquishment in perpetuity of all present
    and future rights to this software under copyright law.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
// EoF