Windows/Linux通用c语言日志log库（零依赖）

#ifndef __CLOG_H__
#define __CLOG_H__
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
///////////////////////////////////////////////////////////////////////////
// Disable all warning: _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#include <io.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <direct.h>
#define __off_t        _off_t
#define F_OK       0
#define O_APPEND   _O_APPEND
#define O_CREAT        _O_CREAT
#define O_WRONLY   _O_WRONLY
#define O_CLOEXEC  _O_NOINHERIT
#define DEFFILEMODE 0666
//#define DEFFILEMODE _S_IREAD | _S_IWRITE
#define strcasecmp stricmp
#define sys_get_tid() ::GetCurrentThreadId()
#define PATH_SEPARATOR         "/"
#define PATH_SEPARATOR_CHAR        '/'
#define make_dir(x)                mkdir(x)
#define LOG_STDOUT_FILENO      fileno(stdout)
// For windows implementation of "gettimeofday"
#if defined(_WIN32) || defined(WIN32)
#include <time.h>
#include <WinSock2.h> //I've ommited this line.
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
#define DELTA_EPOCH_IN_MICROSECS  11644473600000000Ui64
#else
#define DELTA_EPOCH_IN_MICROSECS  11644473600000000ULL
#endif
struct timezone
{
    int  tz_minuteswest; /* minutes W of Greenwich */
    int  tz_dsttime;     /* type of dst correction */
};
__inline static
int gettimeofday(struct timeval* tv, struct timezone* tz)
{
    FILETIME f = { 0 };
    static char _tz = 0x00;
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
    unsigned long long u = 0Ui64;
#else
    unsigned long long u = 0ULL;
#endif
    if (tv)
    {
#ifdef _WIN32_WCE 
        SYSTEMTIME s = { 0 };
        ::GetSystemTime(&s);
        ::SystemTimeToFileTime(&s, &f);
#else 
        ::GetSystemTimeAsFileTime(&f);
#endif 
        u |= f.dwHighDateTime;
        u <<= 32;
        u |= f.dwLowDateTime;
        //convert into microseconds
        u /= 10;
        //converting file time to unix epoch
        u -= DELTA_EPOCH_IN_MICROSECS;
        tv->tv_sec = (long)(u / 1000000UL);
        tv->tv_usec = (long)(u % 1000000UL);
    }
    if (tz)
    {
        if (_tz == 0x00)
        {
            _tzset();
            _tz = 0x01;
        }
        tz->tz_minuteswest = _timezone / 60;
        tz->tz_dsttime = _daylight;
    }
    return 0;
}
#endif
/*static CRITICAL_SECTION log_locker = { 0 };
#define log_init_lock() InitializeCriticalSection(&log_locker)
#define log_lock()     EnterCriticalSection(&log_locker)
#define log_unlock()   LeaveCriticalSection(&log_locker)
#define log_exit_lock() DeleteCriticalSection(&log_locker)*/
#else
///////////////////////////////////////////////////////////////////////////
#include <stdarg.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <pthread.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/syscall.h>
#define sys_get_tid() syscall(SYS_gettid)
#define PATH_SEPARATOR         "/"
#define PATH_SEPARATOR_CHAR        '/'
#define make_dir(x)                mkdir(x, DEFFILEMODE)
#define LOG_STDOUT_FILENO      STDOUT_FILENO
/*static pthread_mutex_t log_locker;
#define log_init_lock() pthread_mutex_init(&log_locker,0)
#define log_lock()     pthread_mutex_lock(&log_locker)
#define log_unlock()   pthread_mutex_unlock(&log_locker)
#define log_exit_lock() pthread_mutex_destroy(&log_locker)*/
#endif
#define MAX_LOG_PATH           4096
#define DATA_SIZE              102400
#define DAY_SECONDS                86400
#define DEFAULT_LOG_ROTATETIME DAY_SECONDS
#define DEFAULT_LOG_LIMIT_SIZE 10*1024*1024
#define DEFAULT_LOG_FMT            ""
#define DEFAULT_LOG_EXT            ".log"
#define DEFAULT_LOG_PATH       "." PATH_SEPARATOR
#define DEFAULT_LOG_CONS       0xFF
#define NEED_LOG_CONS(X)       (X!=0x00)
#define LOG_FILE_FORMAT            "%Y-%m-%d %H:%M:%S"
#define LOG_LR                 '\r'
#define LOG_CF                 '\n'
#pragma pack (1)
struct log_arg {
    int fd;
    long num;
    long idx;
    time_t ftime;
    char fname[64];
    char lname[MAX_LOG_PATH];
    long size;
    char* data;
};
struct log_set {
    long args;
    int level;
    char ext[8];
    char fmt[64];
    __off_t limit;
    long rotatetime;
    unsigned char cons;
    char path[MAX_LOG_PATH];
    struct log_arg* argl;
};
#pragma pack ()
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
#define __CLOG_GLOBAL_MACROS_DEFINE__ static CRITICAL_SECTION log_locker = { 0 };static struct log_set* p_log_set = 0;
#define __CLOG_GLOBAL_MACROS_EXTERN__ extern CRITICAL_SECTION log_locker;extern struct log_set* p_log_set;
#define log_init_lock()        InitializeCriticalSection(&log_locker)
#define log_lock()         EnterCriticalSection(&log_locker)
#define log_unlock()       LeaveCriticalSection(&log_locker)
#define log_exit_lock()        DeleteCriticalSection(&log_locker)
#else
#define __CLOG_GLOBAL_MACROS_DEFINE__  static pthread_mutex_t log_locker;static struct log_set* p_log_set = 0;
#define __CLOG_GLOBAL_MACROS_EXTERN__ extern pthread_mutex_t log_locker;extern struct log_set* p_log_set;
#define log_init_lock()        pthread_mutex_init(&log_locker,0)
#define log_lock()         pthread_mutex_lock(&log_locker)
#define log_unlock()       pthread_mutex_unlock(&log_locker)
#define log_exit_lock()        pthread_mutex_destroy(&log_locker)
#endif
__CLOG_GLOBAL_MACROS_DEFINE__
__CLOG_GLOBAL_MACROS_EXTERN__
enum log_level_type
{
    LOG_NONE = 0,
    LOG_FATAL,
    LOG_ERROR,
    LOG_WARN,
    LOG_INFO,
    LOG_DEBUG,
    LOG_TRACE,
    LOG_VERBOSE,
    LOG_MAX,
};
#define IS_VALID_LOG_LEVEL_TYPE(X) (X > LOG_NONE && X < LOG_MAX)
static const char* p_log_level_name[LOG_MAX] = {
    "NONE",
    "FATAL",
    "ERROR",
    "WARN",
    "INFO",
    "DEBUG",
    "TRACE",
    "VERBOSE"
};
#define NONE_COLOR "\033[00m"
static const char* p_log_level_color[LOG_MAX] = {
    "\033[30m",
    "\033[31m",
    "\033[32m",
    "\033[33m",
    "\033[34m",
    "\033[35m",
    "\033[36m",
    "\033[37m"
};
__inline static
time_t get_log_rotatetime()
{
    return p_log_set->rotatetime;
}
__inline static
const char* get_log_path()
{
    return p_log_set->path;
}
__inline static
const char* get_log_ext()
{
    return p_log_set->ext;
}
__inline static
const char* get_log_fmt()
{
    return p_log_set->fmt;
}
__inline static
__off_t get_log_limit()
{
    return p_log_set->limit;
}
__inline static
int get_log_top_level()
{
    return p_log_set->level;
}
__inline static
unsigned char get_log_cons()
{
    return p_log_set->cons;
}
__inline static
const char* get_log_level_name(int level)
{
    return p_log_level_name[level];
}
__inline static
const char* get_log_level_color(int level)
{
    return p_log_level_color[level];
}
__inline static
const char* get_log_level_color_end()
{
    return NONE_COLOR;
}
__inline static
struct log_arg* get_log_arg(const char* fname)
{
    for (long i = 0; i < p_log_set->args; i++)
    {
        if (strcasecmp(p_log_set->argl[i].fname, fname) == 0)
        {
            return &p_log_set->argl[i];
        }
    }
    return (0);
}
__inline static
int exit_log()
{
    if (p_log_set)
    {
        if (p_log_set->argl)
        {
            for (long i = 0; i < p_log_set->args; i++)
            {
                if (p_log_set->argl[i].fd != (-1))
                {
                    close(p_log_set->argl[i].fd);
                    p_log_set->argl[i].fd = (-1);
                }
                if (p_log_set->argl[i].data != 0)
                {
                    free(p_log_set->argl[i].data);
                    p_log_set->argl[i].data = 0;
                }
            }
            free(p_log_set->argl);
            p_log_set->argl = (0);
        }
        free(p_log_set);
        p_log_set = (0);
    }
    log_exit_lock();
    return 0;
}
__inline static
struct log_set* init_log(const char* path, const char* fmt, const char* ext, unsigned char cons,
    long rotatetime, int level, long limit, const struct log_arg* pargl, unsigned long args)
{
    char* p = 0;
    int nCount = 0;
    time_t log_secs = 0;
    struct tm* tm_log = 0;
    struct timeval tv = { 0 };
    struct timezone tz = { 0 };
    char lname[MAX_LOG_PATH] = { 0 };
    char tpath[MAX_LOG_PATH] = { 0 };
    char lpath[MAX_LOG_PATH] = { 0 };
    size_t path_len = strlen(path);
    size_t tpath_size = sizeof(tpath) / sizeof(*tpath);
    log_init_lock();
    if (p_log_set == 0)
    {
        p_log_set = (struct log_set*)malloc(sizeof(struct log_set));
        if (p_log_set == 0)
        {
            exit_log();
            return (0);
        }
    }
    for (size_t i = 0; i < path_len && i < tpath_size; i++)
    {
        if (path[i] == '\\')
        {
            tpath[i] = '/';
        }
        else
        {
            tpath[i] = path[i];
        }
    }
    if (tpath[strlen(tpath) - 1] != '/')
    {
        tpath[strlen(tpath)] = '/';
    }
    p = (char*)tpath;
    while (((p = strchr((char*)tpath + (p - tpath), PATH_SEPARATOR_CHAR)) != 0))
    {
        snprintf(lpath, sizeof(lpath) / sizeof(*lpath), "%.*s\0", (int)((++p) - tpath), tpath);
        make_dir(lpath);
    }
    snprintf(p_log_set->path, sizeof(p_log_set->path) / sizeof(*(p_log_set->path)), "%s\0", (tpath != 0) ? (tpath) : DEFAULT_LOG_PATH);
    if ((p_log_set->path[strlen(p_log_set->path) - 1] != PATH_SEPARATOR_CHAR))
    {
        p_log_set->path[strlen(p_log_set->path)] = PATH_SEPARATOR_CHAR;
    }
    snprintf(p_log_set->fmt, sizeof(p_log_set->fmt) / sizeof(*(p_log_set->fmt)), "%s\0", (fmt != 0) ? (fmt) : "");
    snprintf(p_log_set->ext, sizeof(p_log_set->ext) / sizeof(*(p_log_set->ext)), "%s\0", (tpath != 0) ? (ext) : DEFAULT_LOG_EXT);
    p_log_set->level = IS_VALID_LOG_LEVEL_TYPE(level) ? level : LOG_VERBOSE;
    p_log_set->limit = limit > 0 ? limit : DEFAULT_LOG_LIMIT_SIZE;
    p_log_set->cons = cons;
    p_log_set->args = args;
    p_log_set->rotatetime = rotatetime > 0 ? rotatetime : DAY_SECONDS;
    p_log_set->argl = (struct log_arg*)malloc(p_log_set->args * sizeof(struct log_arg));
    if (p_log_set->argl == 0)
    {
        exit_log();
        return (0);
    }
    memset(p_log_set->argl, 0, p_log_set->args * sizeof(struct log_arg));
    gettimeofday(&tv, &tz);
    log_secs = tv.tv_sec;
    log_secs -= log_secs % p_log_set->rotatetime;
    for (long i = 0; i < p_log_set->args; i++)
    {
        nCount = 0;
        memcpy(&p_log_set->argl[i], &pargl[i], sizeof(struct log_arg));
        p_log_set->argl[i].data = (char*)malloc(p_log_set->argl[i].size);
        if (p_log_set->argl[i].data == 0)
        {
            exit_log();
            return (0);
        }
        nCount += snprintf(lname + nCount, sizeof(lname) / sizeof(*lname), "%s%s\0", p_log_set->path, p_log_set->argl[i].fname);
        if (*p_log_set->fmt)
        {
            tm_log = localtime(&log_secs);
            nCount += (int)(strftime(lname + nCount, sizeof(lname) / sizeof(*lname), p_log_set->fmt, tm_log));
        }
        p_log_set->argl[i].ftime = log_secs;
        nCount += snprintf(lname + nCount, sizeof(lname) / sizeof(*lname), "%s\0", p_log_set->ext);
        snprintf(p_log_set->argl[i].lname, sizeof(p_log_set->argl[i].lname) / sizeof(*p_log_set->argl[i].lname), "%s\0", lname);
        for (long n = 0; n < p_log_set->argl[i].num; n++)
        {
            snprintf(lname, sizeof(lname) / sizeof(*lname), "%s.%d\0", p_log_set->argl[i].lname, n);
            if (access(lname, F_OK) != 0)
            {
                p_log_set->argl[i].idx = (n + 1);
                p_log_set->argl[i].idx %= (p_log_set->argl[i].num + 1);
                p_log_set->argl[i].idx = (p_log_set->argl[i].idx <= 0) ? 1 : p_log_set->argl[i].idx;
                break;
            }
        }
        p_log_set->argl[i].fd = open(p_log_set->argl[i].lname, O_APPEND | O_CREAT | O_WRONLY | O_CLOEXEC, DEFFILEMODE);
        if (p_log_set->argl[i].fd == (-1))
        {
            printf("%d,%s\n", errno, strerror(errno));
            exit_log();
            return (0);
        }
    }
    return (p_log_set);
}
__inline static
int check_log(struct log_arg* pla, time_t now_secs)
{
    int nCount = 0;
    time_t fsecs = 0;
    struct stat st = { 0 };
    __off_t limit = get_log_limit();
    const char* ext = get_log_ext();
    const char* fmt = get_log_fmt();
    char lname[MAX_LOG_PATH] = { 0 };
    const char* path = get_log_path();
    fsecs = now_secs - now_secs % get_log_rotatetime();
    if (pla->ftime != fsecs)
    {
        pla->ftime = fsecs;
        nCount += snprintf(lname + nCount, sizeof(lname) / sizeof(*lname), "%s%s\0", path, pla->fname);
        if (*fmt)
        {
            nCount += (int)(strftime(lname + nCount, sizeof(lname) / sizeof(*lname), fmt, localtime(&fsecs)));
            nCount += snprintf(lname + nCount, sizeof(lname) / sizeof(*lname), "%s\0", ext);
            close(pla->fd);
            snprintf(pla->lname, sizeof(pla->lname) / sizeof(*pla->lname), "%s\0", lname);
            int fd = open(pla->lname, O_APPEND | O_CREAT | O_WRONLY | O_CLOEXEC, DEFFILEMODE);
            if (fd == (-1))
            {
                pla->fd = (-1);
                printf("open log file %s failed. msg: (errno=%d)%s\n", pla->fname, errno, strerror(errno));
                return (-1);
            }
            dup2(fd, pla->fd);
            if (fd != pla->fd)
            {
                close(fd);
            }
        }
        else
        {
            if (pla->num > 0)
            {
                pla->idx %= (pla->num + 1);
                pla->idx = (pla->idx <= 0) ? 1 : pla->idx;
            }
            snprintf(lname, sizeof(lname) / sizeof(*lname), "%s.%d\0", pla->lname, pla->idx++);
            close(pla->fd);
            unlink(lname);
            if (rename(pla->lname, lname) != 0)
            {
                pla->fd = (-1);
                printf("rename logfile %s -> %s failed msg: (errno=%d)%s\n", pla->lname, lname, errno, strerror(errno));
                return (-1);
            }
            int fd = open(pla->lname, O_APPEND | O_CREAT | O_WRONLY | O_CLOEXEC, DEFFILEMODE);
            if (fd == (-1))
            {
                pla->fd = (-1);
                printf("open log file %s failed. msg: (errno=%d)%s\n", pla->fname, errno, strerror(errno));
                return (-1);
            }
            dup2(fd, pla->fd);
            if (fd != pla->fd)
            {
                close(fd);
            }
        }
    }
    else
    {
        if (fstat(pla->fd, &st) == (-1))
        {
            switch (errno)
            {
            case ENOENT:
            {
                nCount += snprintf(lname + nCount, sizeof(lname) / sizeof(*lname), "%s%s\0", path, pla->fname);
                if (*fmt)
                {
                    nCount += (int)(strftime(lname + nCount, sizeof(lname) / sizeof(*lname), fmt, localtime(&now_secs)));
                }
                nCount += snprintf(lname + nCount, sizeof(lname) / sizeof(*lname), "%s\0", ext);
                snprintf(pla->lname, sizeof(pla->lname) / sizeof(*pla->lname), "%s\0", lname);
                pla->fd = open(pla->lname, O_APPEND | O_CREAT | O_WRONLY | O_CLOEXEC, DEFFILEMODE);
                if (pla->fd == (-1))
                {
                    printf("open log file %s failed. msg: (errno=%d)%s\n", pla->fname, errno, strerror(errno));
                    return (-1);
                }
            }
            break;
            default:
            {
                printf("stat log file %s failed. msg: (errno=%d)%s\n", pla->fname, errno, strerror(errno));
                return (-1);
            }
            break;
            }
        }
        else
        {
            if (st.st_size + pla->size >= limit)
            {
                if (pla->num > 0)
                {
                    pla->idx %= (pla->num + 1);
                    pla->idx = (pla->idx <= 0) ? 1 : pla->idx;
                }
                snprintf(lname, sizeof(lname) / sizeof(*lname), "%s.%d\0", pla->lname, pla->idx++);
                close(pla->fd);
                unlink(lname);
                if (rename(pla->lname, lname) != 0)
                {
                    pla->fd = (-1);
                    printf("rename logfile %s -> %s failed msg: (errno=%d)%s\n", pla->lname, lname, errno, strerror(errno));
                    return (-1);
                }
                int fd = open(pla->lname, O_APPEND | O_CREAT | O_WRONLY | O_CLOEXEC, DEFFILEMODE);
                if (fd == (-1))
                {
                    pla->fd = (-1);
                    printf("open log file %s failed. msg: (errno=%d)%s\n", pla->fname, errno, strerror(errno));
                    return (-1);
                }
                dup2(fd, pla->fd);
                if (fd != pla->fd)
                {
                    close(fd);
                }
            }
        }
    }
    return (0);
}
__inline static
int log(const char* fname, int level, const char* fmt, ...)
{
    va_list arg;
    int data_len = 0;
    long tt_now_usecs = 0;
    struct stat st = { 0 };
    struct tm* tm_now = 0;
    time_t tt_now_secs = 0;
    struct log_arg* pla = 0;
    struct timeval tv = { 0 };
    struct timezone tz = { 0 };
    char date_time[128] = { 0 };
    // 若level大于指定的level,则不打印日志信息
    if (level > get_log_top_level())
    {
        return (-1);
    }
    if ((pla = get_log_arg(fname)) == 0)
    {
        return (-1);
    }
    log_lock();
    memset(pla->data, 0, pla->size);
    gettimeofday(&tv, &tz);
    tt_now_secs = tv.tv_sec;
    tt_now_usecs = tv.tv_usec;
    tm_now = localtime(&tt_now_secs);
    strftime(date_time, sizeof(date_time) / sizeof(*date_time), LOG_FILE_FORMAT, tm_now);
    data_len += snprintf(pla->data + data_len, pla->size, "%s[%s.%ld][%ld][%C]\0",
        get_log_level_color(level), date_time, tt_now_usecs, sys_get_tid(), *get_log_level_name(level));
    va_start(arg, fmt);
    data_len += vsnprintf(pla->data + data_len, pla->size, fmt, arg);
    va_end(arg);
    if (LOG_CF == pla->data[data_len - 1])
    {
        data_len--;
        if (LOG_LR == pla->data[data_len - 1])
        {
            data_len--;
        }
    }
    data_len += snprintf(pla->data + data_len, pla->size, "%s\n\0", get_log_level_color_end());
    check_log(pla, tt_now_secs);
    write(pla->fd, pla->data, data_len);
    if (NEED_LOG_CONS(get_log_cons()))
    {
        //printf("%.*s", data_len, data);
        write(LOG_STDOUT_FILENO, pla->data, data_len);
    }
    log_unlock();
    return (0);
}
//#define LOG(NAME,LEVEL,FMT...)       log(#NAME,LEVEL,##FMT)
#define LOG(NAME,LEVEL,FMT,...)    log(#NAME,LEVEL,FMT,##__VA_ARGS__)
/////////////////////////////////////////////////////////////////////////////////////////////////
__inline static
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
DWORD
#else
void*
#endif
log_task(void* p) {
    for (size_t i = 0; i < 1000; i++)
    {
        log("main", LOG_INFO, "%s(%d)\n", "I am test!!!!!!", i);
        LOG(main, LOG_WARN, "%s(%d)\n", "I am test!!!!!!", i);
        LOG(main, LOG_TRACE, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_ERROR, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_FATAL, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_WARN, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_TRACE, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_DEBUG, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_INFO, "%s(%d)\n", "I am test!!!!!!", i);
        LOG(main1, LOG_WARN, "%s(%d)\n", "I am test!!!!!!", i);
        LOG(main1, LOG_TRACE, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_ERROR, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_FATAL, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_WARN, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_TRACE, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_DEBUG, "%s(%d)\n", "I am test!!!!!!", i);
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
        //_sleep(1000);
    }
    return (0);
#else
        usleep(1000000);
}
    pthread_exit(0);
    return (void*)(0);
#endif
}
__inline static
int log_test_init()
{
    const struct log_arg largl[] = {
        {-1,30,0,0,"main","", DATA_SIZE, 0},
        //{-1,30,0,0,"main1","", DATA_SIZE, 0},
    };
    long n_rotatetime = 10;//DEFAULT_LOG_ROTATETIME
    const char* log_fmt = "%Y%m%d%H%M%S";// DEFAULT_LOG_FMT;
    init_log(DEFAULT_LOG_PATH, log_fmt, DEFAULT_LOG_EXT, DEFAULT_LOG_CONS,
        n_rotatetime, LOG_VERBOSE, DEFAULT_LOG_LIMIT_SIZE, largl, sizeof(largl) / sizeof(*largl));
    return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
// >>>>>> copy the content to main.c/main.cpp and build <<<<<<
//
// #include <stdio.h>
// #include "clog.h"
// 
// int main(int argc, char ** argv)
// {
//     printf("hello from clog_test!\n");
// 
//     log_test_main();
// 
//     return 0;
// }
///////////////////////////////////////////////////////////////////////////////////////////////////////
__inline static
int log_test_main()
{
    const struct log_arg largl[] = {
        {-1,30,0,0,"main","", DATA_SIZE, 0},
        {-1,30,0,0,"main1","", DATA_SIZE, 0},
    };
    long n_rotatetime = 10;//DEFAULT_LOG_ROTATETIME
    const char* log_fmt = "%Y%m%d%H%M%S";// DEFAULT_LOG_FMT;
    init_log(DEFAULT_LOG_PATH, log_fmt, DEFAULT_LOG_EXT, DEFAULT_LOG_CONS,
        n_rotatetime, LOG_VERBOSE, DEFAULT_LOG_LIMIT_SIZE, largl, sizeof(largl) / sizeof(*largl));
    for (size_t i = 0; i < 100; i++)
    {
        LOG(main, LOG_INFO, "%s(%d)\n", "I am test!!!!!!", i);
        LOG(main1, LOG_INFO, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_ERROR, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_FATAL, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_WARN, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_TRACE, "%s(%d)\n", "I am test!!!!!!", i);
        log("main", LOG_DEBUG, "%s(%d)\n", "I am test!!!!!!", i);
        log("main1", LOG_INFO, "%s(%d)\n", "I am test!!!!!!", i);
    }
    int ret = 0;
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
    DWORD t[4] = { 0 };
    HANDLE h[4] = { 0 };
    for (int i = 0; i < sizeof(t) / sizeof(*t); i++)
    {
        h[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)log_task, 0, 0, &t[i]);
    }
    getchar();
    WaitForMultipleObjects(sizeof(t) / sizeof(*t), h, TRUE, INFINITE);
#else
    pthread_t t[4] = { 0 };
    for (int i = 0; i < sizeof(t) / sizeof(*t); i++)
    {
        ret = pthread_create(&t[i], 0, log_task, 0);
    }
    getchar();
    for (int i = 0; i < sizeof(t) / sizeof(*t); i++)
    {
        pthread_join(t[i], 0);
    }
#endif
    exit_log();
    return 0;
}
#endif // __CLOG_H__