log.h

Go to the documentation of this file.

 
#ifndef LOG_LOG_H_
#define LOG_LOG_H_
 
#include "../misc/ErrObj.h"
 
#include <errno.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <syslog.h>
 
#define LOG_LOCALTIME 0x100u 
#define LOG_NOTIME    0x200u 
#define LOG_IDENT     0x400u 
 
typedef enum {
    LOG_LEVEL_DEBUG = 0,
    LOG_LEVEL_INFO,     
    LOG_LEVEL_NOTICE,   
    LOG_LEVEL_WARNING,  
    LOG_LEVEL_ERROR,    
    LOG_LEVEL_FATAL,    
    LOG_LEVEL_COUNT     
} log_level_t;
 
/*
 * The declarations in the following header-file are package-private -- so don't
 * use them.
 */
#include "log_private.h"
 
#ifdef __cplusplus
    extern "C" {
#endif
 
const char* log_get_default_daemon_destination(void);
 
const char* log_get_default_destination(void);
 
bool log_stderr_is_open(void);
 
bool log_amDaemon(void);
 
int log_init(const char* const id);
 
void log_avoid_stderr(void);
 
void log_refresh(void);
 
#define log_fini() do {\
    LOG_LOC_DECL(loc);\
    (void)log_fini_located(&loc);\
} while (false)
 
int log_set_level(
        const log_level_t level);
 
log_level_t log_get_level(void);
 
void log_roll_level(void);
 
int log_set_id(
        const char* const id);
 
int log_set_upstream_id(
        const char* const hostId,
        const bool        isFeeder);
 
const char* log_get_id(void);
 
int log_set_options(
        const unsigned options);
 
unsigned log_get_options(void);
 
int log_set_facility(
        const int facility);
 
int log_get_facility(void);
 
int log_set_destination(
        const char* const dest);
 
const char* log_get_destination(void);
 
void log_clear(void);
 
int log_dispose(
        const log_level_t level,
        ErrObj*           errObj);
 
#define log_free() do {\
    int prevState; \
    (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &prevState); \
    LOG_LOC_DECL(loc);\
    log_free_located(&loc);\
    (void)pthread_setcancelstate(prevState, &prevState); \
} while (false)
 
bool log_is_level_enabled(
        const log_level_t level);
 
#define log_is_enabled_warning  log_is_level_enabled(LOG_LEVEL_WARNING)
#define log_is_enabled_notice   log_is_level_enabled(LOG_LEVEL_NOTICE)
#define log_is_enabled_info     log_is_level_enabled(LOG_LEVEL_INFO)
#define log_is_enabled_debug    log_is_level_enabled(LOG_LEVEL_DEBUG)
 
#define log_log(level, ...) do {\
    if ((level) >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, (level), __VA_ARGS__);\
    }\
} while (0)
 
#define log_debug(...) do {\
    if (LOG_LEVEL_DEBUG >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, LOG_LEVEL_DEBUG, __VA_ARGS__);\
    }\
} while (0)
 
#define log_info(...) do {\
    if (LOG_LEVEL_INFO >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, LOG_LEVEL_INFO, __VA_ARGS__);\
    }\
} while (0)
 
#define log_notice(...) do {\
    if (LOG_LEVEL_NOTICE >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, LOG_LEVEL_NOTICE, __VA_ARGS__);\
    }\
} while (0)
 
#define log_warning(...) do {\
    if (LOG_LEVEL_WARNING >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, LOG_LEVEL_WARNING, __VA_ARGS__);\
    }\
} while (0)
 
#define log_error(...) do {\
    if (LOG_LEVEL_ERROR >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, LOG_LEVEL_ERROR, __VA_ARGS__);\
    }\
} while (0)
 
#define log_fatal(...) do {\
    if (LOG_LEVEL_FATAL >= log_level) {\
        LOG_LOC_DECL(loc);\
        logl_log(&loc, LOG_LEVEL_FATAL, __VA_ARGS__);\
    }\
} while (0)
 
#define log_errno(errnum, ...) do {\
    LOG_LOC_DECL(loc);\
    logl_errno(&loc, errnum, __VA_ARGS__);\
} while (0)
 
#define log_syserr(...) log_errno(errno, __VA_ARGS__)
 
#define log_add(...) do { \
    LOG_LOC_DECL(loc); \
    logl_add(&loc, __VA_ARGS__);\
} while (false)
 
#define log_vadd(fmt, args) do { \
    LOG_LOC_DECL(loc); \
    logl_vadd(&loc, fmt, args); \
} while (false)
 
#define log_add_errno(n, ...) do {\
    LOG_LOC_DECL(loc); \
    logl_add_errno(&loc, n, __VA_ARGS__); \
} while (false)
 
#define log_add_syserr(...)  log_add_errno(errno, __VA_ARGS__)
 
#define log_error_q(...)       LOG_LOG(LOG_LEVEL_ERROR,   __VA_ARGS__)
#define log_warning_q(...)     LOG_LOG(LOG_LEVEL_WARNING, __VA_ARGS__)
#define log_notice_q(...)      LOG_LOG(LOG_LEVEL_NOTICE,  __VA_ARGS__)
#define log_info_q(...)        LOG_LOG(LOG_LEVEL_INFO,    __VA_ARGS__)
#define log_debug_q(...) do {\
    LOG_LOC_DECL(loc);\
    logl_log_q(&loc, LOG_LEVEL_DEBUG, __VA_ARGS__);\
} while (0)
#define log_log_q(level, ...)  LOG_LOG(level, __VA_ARGS__)
 
int
log_flush(const log_level_t level);
 
#define log_flush_fatal()    log_flush(LOG_LEVEL_FATAL)
#define log_flush_error()    log_flush(LOG_LEVEL_ERROR)
#define log_flush_warning()  log_flush(LOG_LEVEL_WARNING)
#define log_flush_notice()   log_flush(LOG_LEVEL_NOTICE)
#define log_flush_info()     log_flush(LOG_LEVEL_INFO)
#define log_flush_debug()    log_flush(LOG_LEVEL_DEBUG)
 
#define log_malloc(nbytes, msg) logl_malloc(__FILE__, __func__, __LINE__, \
        nbytes, msg)
 
#define log_realloc(buf, nbytes, msg) logl_realloc(__FILE__, __func__, __LINE__, \
        buf, nbytes, msg)
 
#define log_abort(...) do { \
    log_add(__VA_ARGS__); \
    log_flush(LOG_LEVEL_ERROR); \
    abort(); \
} while (false)
 
#ifdef NDEBUG
    #define log_assert(expr)
#else
    #define log_assert(expr) do { \
        int prevState; \
        (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &prevState); \
        if (!(expr)) \
            log_abort("Assertion failure: %s", #expr); \
        (void)pthread_setcancelstate(prevState, &prevState); \
    } while (false)
#endif
 
#ifdef __cplusplus
    }
#endif
 
#endif /* LOG_LOG_H_ */