ToB企服应用市场:ToB评测及商务社交产业平台

标题: 轻量级c语言开源日记库log.c先容 - 实现差异级别和参数化日记打印 [打印本页]

---

作者: 八卦阵    时间: 2024-9-6 00:07
标题: 轻量级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. }

    复制代码
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4