轻量级c语言开源日志库log.c介绍 - 实现不同级别和参数化日志打印

前言

• c语言没有现成的日志库，如果要记录日志，需要自己封装一个日志库。如果要实现日志级别和参数打印，还是比较麻烦的，正好在github找到了一个c语言开源日志库，可以实现日志级别打印，参数打印，而且还会记录日期和行号，最重要的是代码非常少，只有100多行，可以直接包含在我们自己的工程代码中，不需要任何依赖。

源码地址

• github源码连接

使用介绍

• 直接把工程目录下的log.c和log.h下载下来，包含到工程代码中即可，没有其他依赖。
• 日志级别由低到高，分别为 LOG_TRACE、LOG_DEBUG、LOG_INFO、LOG_WARN、LOG_ERROR、LOG_FATAL
• 如果设置日志级别为LOG_TRACE，则所有级别日志都会打印，如果设置日志级别为LOG_WARN，则只会打印LOG_WARN以及更高级别(即LOG_ERROR和LOG_FATAL)的日志

演示

• 测试代码
  • 1. #include "log.h"
    2. #include <stdio.h>
    4. int main() {
    5. FILE *fp = fopen("log.txt", "a+");
    6. if(fp == NULL){
    7. printf("create log file failed.\n");
    8. return -1;
    9. }
    11. //设置日志级别(在终端打印)
    12. log_set_level(LOG_TRACE);
    14. //设置日志级别(在文件中打印)
    15. log_add_fp(fp, LOG_INFO);
    18. log_trace("start trace.");
    19. log_debug("start debug.");
    20. log_info("start info.");
    21. log_warn("start warn.");
    22. log_error("start error.");
    23. log_fatal("start fatal");
    25. // 支持参数打印
    26. log_info("number is %d, string is %s", 10010, "helloword");
    28. fclose(fp);
    29. }

    复制代码
• 演示效果
  

源码

• 如果访问github有问题，我把源码贴到下面了。
• log.h
  • 1. #ifndef LOG_H
    2. #define LOG_H
    4. #include <stdio.h>
    5. #include <stdarg.h>
    6. #include <stdbool.h>
    7. #include <time.h>
    9. #define LOG_VERSION "0.1.0"
    11. typedef struct {
    12. va_list ap;
    13. const char *fmt;
    14. const char *file;
    15. struct tm *time;
    16. void *udata;
    17. int line;
    18. int level;
    19. } log_Event;
    21. typedef void (*log_LogFn)(log_Event *ev);
    22. typedef void (*log_LockFn)(bool lock, void *udata);
    24. enum { LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR, LOG_FATAL };
    26. #define log_trace(...) log_log(LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
    27. #define log_debug(...) log_log(LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
    28. #define log_info(...) log_log(LOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
    29. #define log_warn(...) log_log(LOG_WARN, __FILE__, __LINE__, __VA_ARGS__)
    30. #define log_error(...) log_log(LOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
    31. #define log_fatal(...) log_log(LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
    33. const char* log_level_string(int level);
    34. void log_set_lock(log_LockFn fn, void *udata);
    35. void log_set_level(int level);
    36. void log_set_quiet(bool enable);
    37. int log_add_callback(log_LogFn fn, void *udata, int level);
    38. int log_add_fp(FILE *fp, int level);
    40. void log_log(int level, const char *file, int line, const char *fmt, ...);
    42. #endif

    复制代码
• log.c
  • 1. #include "log.h"
    2. #define MAX_CALLBACKS 32
    4. typedef struct {
    5. log_LogFn fn;
    6. void *udata;
    7. int level;
    8. } Callback;
    10. static struct {
    11. void *udata;
    12. log_LockFn lock;
    13. int level;
    14. bool quiet;
    15. Callback callbacks[MAX_CALLBACKS];
    16. } L;
    19. static const char *level_strings[] = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
    21. #ifdef LOG_USE_COLOR
    22. static const char *level_colors[] = {"\x1b[94m", "\x1b[36m", "\x1b[32m", "\x1b[33m", "\x1b[31m", "\x1b[35m"};
    23. #endif
    26. static void stdout_callback(log_Event *ev) {
    27. char buf[16];
    28. buf[strftime(buf, sizeof(buf), "%H:%M:%S", ev->time)] = '\0';
    29. #ifdef LOG_USE_COLOR
    30. fprintf(ev->udata, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ", buf, level_colors[ev->level], level_strings[ev->level], ev->file, ev->line);
    31. #else
    32. fprintf(ev->udata, "%s %-5s %s:%d: ", buf, level_strings[ev->level], ev->file, ev->line);
    33. #endif
    34. vfprintf(ev->udata, ev->fmt, ev->ap);
    35. fprintf(ev->udata, "\n");
    36. fflush(ev->udata);
    37. }
    39. static void file_callback(log_Event *ev) {
    40. char buf[64];
    41. buf[strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ev->time)] = '\0';
    42. fprintf(ev->udata, "%s %-5s %s:%d: ", buf, level_strings[ev->level], ev->file, ev->line);
    43. vfprintf(ev->udata, ev->fmt, ev->ap);
    44. fprintf(ev->udata, "\n");
    45. fflush(ev->udata);
    46. }
    48. static void lock(void) {
    49. if (L.lock) {
    50. L.lock(true, L.udata);
    51. }
    52. }
    54. static void unlock(void) {
    55. if (L.lock) {
    56. L.lock(false, L.udata);
    57. }
    58. }
    60. const char* log_level_string(int level) {
    61. return level_strings[level];
    62. }
    64. void log_set_lock(log_LockFn fn, void *udata) {
    65. L.lock = fn;
    66. L.udata = udata;
    67. }
    69. void log_set_level(int level) {
    70. L.level = level;
    71. }
    74. void log_set_quiet(bool enable) {
    75. L.quiet = enable;
    76. }
    79. int log_add_callback(log_LogFn fn, void *udata, int level) {
    80. for (int i = 0; i < MAX_CALLBACKS; i++) {
    81. if (!L.callbacks[i].fn) {
    82. L.callbacks[i] = (Callback) { fn, udata, level };
    83. return 0;
    84. }
    85. }
    86. return -1;
    87. }
    90. int log_add_fp(FILE *fp, int level) {
    91. return log_add_callback(file_callback, fp, level);
    92. }
    95. static void init_event(log_Event *ev, void *udata) {
    96. if (!ev->time) {
    97. time_t t = time(NULL);
    98. ev->time = localtime(&t);
    99. }
    100. ev->udata = udata;
    101. }
    104. void log_log(int level, const char *file, int line, const char *fmt, ...) {
    105. log_Event ev = {
    106. .fmt = fmt,
    107. .file = file,
    108. .line = line,
    109. .level = level,
    110. };
    112. lock();
    114. if (!L.quiet && level >= L.level) {
    115. init_event(&ev, stderr);
    116. va_start(ev.ap, fmt);
    117. stdout_callback(&ev);
    118. va_end(ev.ap);
    119. }
    121. for (int i = 0; i < MAX_CALLBACKS && L.callbacks[i].fn; i++) {
    122. Callback *cb = &L.callbacks[i];
    123. if (level >= cb->level) {
    124. init_event(&ev, cb->udata);
    125. va_start(ev.ap, fmt);
    126. cb->fn(&ev);
    127. va_end(ev.ap);
    128. }
    129. }
    131. unlock();
    132. }

    复制代码
• windows平台编译时有报错，结构体赋值语法不支持，我做了修改。
• 修改后的 log.c
  • 1. #include "log.h"
    3. #define MAX_CALLBACKS 32
    5. typedef struct {
    6. log_LogFn fn;
    7. void *udata;
    8. int level;
    9. } Callback;
    11. static struct {
    12. void *udata;
    13. log_LockFn lock;
    14. int level;
    15. bool quiet;
    16. Callback callbacks[MAX_CALLBACKS];
    17. } L;
    19. static const char *level_strings[] = {"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
    21. #ifdef LOG_USE_COLOR
    22. static const char *level_colors[] = {"\x1b[94m", "\x1b[36m", "\x1b[32m", "\x1b[33m", "\x1b[31m", "\x1b[35m"};
    23. #endif
    25. static void stdout_callback(log_Event *ev) {
    26. char buf[100] = {0};
    27. time_t timep;
    28. time(&timep);
    29. struct tm *pt = gmtime(&timep);
    30. sprintf(buf, "%d-%02d-%02d %02d:%02d:%02d", 1900 + pt->tm_year, 1 + pt->tm_mon, pt->tm_mday, (8 + pt->tm_hour) % 24, pt->tm_min, pt->tm_sec);
    31. #ifdef LOG_USE_COLOR
    32. fprintf((FILE *)ev->udata, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ", buf, level_colors[ev->level], level_strings[ev->level], ev->file, ev->line);
    33. #else
    34. fprintf((FILE *)ev->udata, "%s %-5s %s:%d: ", buf, level_strings[ev->level], ev->file, ev->line);
    35. #endif
    36. vfprintf((FILE *)ev->udata, ev->fmt, ev->ap);
    37. fprintf((FILE *)ev->udata, "\n");
    38. fflush((FILE *)ev->udata);
    39. }
    41. static void file_callback(log_Event *ev) {
    42. char buf[100] = {0};
    43. time_t timep;
    44. time(&timep);
    45. struct tm *pt = gmtime(&timep);
    46. sprintf(buf, "%d-%02d-%02d %02d:%02d:%02d", 1900 + pt->tm_year, 1 + pt->tm_mon, pt->tm_mday, (8 + pt->tm_hour) % 24, pt->tm_min, pt->tm_sec);
    47. fprintf((FILE *)ev->udata, "%s %-5s %s:%d: ", buf, level_strings[ev->level], ev->file, ev->line);
    48. vfprintf((FILE *)ev->udata, ev->fmt, ev->ap);
    49. fprintf((FILE *)ev->udata, "\n");
    50. fflush((FILE *)ev->udata);
    51. }
    53. static void lock(void) {
    54. if (L.lock) {
    55. L.lock(true, L.udata);
    56. }
    57. }
    59. static void unlock(void) {
    60. if (L.lock) {
    61. L.lock(false, L.udata);
    62. }
    63. }
    65. const char *log_level_string(int level) { return level_strings[level]; }
    67. void log_set_lock(log_LockFn fn, void *udata) {
    68. L.lock = fn;
    69. L.udata = udata;
    70. }
    72. void log_set_level(int level) { L.level = level; }
    74. void log_set_quiet(bool enable) { L.quiet = enable; }
    76. int log_add_callback(log_LogFn fn, void *udata, int level) {
    77. for (int i = 0; i < MAX_CALLBACKS; i++) {
    78. if (!L.callbacks[i].fn) {
    79. L.callbacks[i].fn = fn;
    80. L.callbacks[i].udata = udata;
    81. L.callbacks[i].level = level;
    82. return 0;
    83. }
    84. }
    85. return -1;
    86. }
    88. int log_add_fp(FILE *fp, int level) { return log_add_callback(file_callback, fp, level); }
    90. static void init_event(log_Event *ev, void *udata) {
    91. if (!ev->time) {
    92. time_t t = time(NULL);
    93. ev->time = gmtime(&t);
    94. }
    95. ev->udata = udata;
    96. }
    98. void log_log(int level, const char *file, int line, const char *fmt, ...) {
    99. log_Event ev;
    100. ev.fmt = fmt;
    101. ev.file = file;
    102. ev.line = line;
    103. ev.level = level;
    105. lock();
    107. if (!L.quiet && level >= L.level) {
    108. init_event(&ev, stderr);
    109. va_start(ev.ap, fmt);
    110. stdout_callback(&ev);
    111. va_end(ev.ap);
    112. }
    114. for (int i = 0; i < MAX_CALLBACKS && L.callbacks[i].fn; i++) {
    115. Callback *cb = &L.callbacks[i];
    116. if (level >= cb->level) {
    117. init_event(&ev, cb->udata);
    118. va_start(ev.ap, fmt);
    119. cb->fn(&ev);
    120. va_end(ev.ap);
    121. }
    122. }
    124. unlock();
    125. }

    复制代码

新增功能

• 在上述基础上，增加了毫秒级日期的打印，以及windows平台线程id打印。
• 由于用到了系统API，在嵌入式设备上可能不支持。
• 源码地址