Chinaunix首页 | 论坛 | 博客
  • 博客访问: 196228
  • 博文数量: 94
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 650
  • 用 户 组: 普通用户
  • 注册时间: 2015-09-30 08:58
  • 认证徽章:
个人简介

x

文章分类

全部博文(94)

文章存档

2019年(4)

2018年(10)

2017年(26)

2016年(38)

2015年(16)

我的朋友

分类: LINUX

2019-03-04 14:19:26

logrus学习笔记

1.logrus.Entry结构

1.1 类型

type Entry struct {
    Logger *Logger          // 指向Logger对象
    
    Data Fields             // 包含用户设置的所有字段,Fields结构:type Fields map[string]interface{}
    
    Time time.Time          // log entry创建时间
    
    Level Level             // 可以记录的日志级别为Trace, Debug, Info, Warn, Error, Fatal or Panic
    
    Caller *runtime.Frame   // 带包名的调用时方法,每条日志中记录文件名、函数和行号
    
    Message string          // 要记录的消息
    
    Buffer *bytes.Buffer    // 当在entry.log方法中调用formatter接口实现的方法,Buffer才会被使用到
    
    err string              // 用于记录字段格式化错误
} 

1.2 方法

1. func NewEntry(logger *Logger) *Entry 
  • 功能说明:创建一个新的Entry对象,接口对包外开放

  • 流程分析:传入Logger对象,初始化Entry.Logger和Entry.Data成员

2. func (entry *Entry) String() (string, error) 
  • 功能说明:将Entry中的数据序列化成string,并返回

  • 流程分析:调用entry.Logger.Formatter.Format方法,其中Formatter是一个接口,类型定义如下: 

      type Formatter interface {  
          Format(*Entry) ([]byte, error)
      }

    Logger.Formatter在logrus/logger.go中默认初始化为TextFormatter,见方法“func New() *Logger”,或者
    使用方法Logger.SetFormatter初始化,常用的Formatter有:TextFormatter、JSONFormatter,也可自定义实现Formatter接口

3. func (entry *Entry) WithError(err error) *Entry 
  • 功能说明:添加err字段到Entry.Data中,返回一个新的entry对象

  • 流程分析:详解见Entry.WithField

4. func (entry *Entry) WithField(key string, value interface{}) *Entry 
  • 功能说明:向Entry.Data字段追加{key, value}字段,并返回一个新的Entry对象

  • 流程分析:详解见Entry.WithFields

5. func (entry *Entry) WithFields(fields Fields) *Entry 
  • 功能说明:向Entry.Data中依次追加fields中包含的若干个字段,其中Fields结构为type Fields map[string]interface{}

  • 流程分析:
    1.先将Entry.Data中原有的元素添加至临时的data变量中
    2.循环添加fields中元素至data中,若添加失败,则将添加的失败信息追加到Entry.err
    3.返回一个新的Entry对象 

6. func (entry *Entry) WithTime(t time.Time) *Entry 
  • 功能说明:修改Entry.Time,并返回一个新的Entry对象

  • 流程分析:无

7. func (entry Entry) log(level Level, msg string) 
  • 功能说明:日志处理的核心部分

  • 流程分析:
    1.初始化entry的Time、Level、Message字段
    2.如果entry.Logger.ReportCaller为true,则获取运行时调用者信息,初始化entry.Caller字段
    3.调用entry.fireHooks方法,处理所有entry.Logger上注册的Hook,详解见entry.fireHooks方法
    4.给entry.Buffer初始化一个*bytes.Buffer对象,以备entry.write中间隔使用,详解见entry.write方法 

    Entry.Caller类型为*runtime.Frame,保存运行时调用者信息,包括文件名、方法名、方法行号等。

    • 系统默认的logger为std,Logger.ReportCaller字段默认为false,可使用Logger.SetReportCaller打开 
8. func (entry *Entry) fireHooks() 
  • 功能说明:处理当前一条日志所有的Hook

  • 流程分析:调用entry.Logger.Hooks.Fire方法,实际是处理entry.Level级别对应的所有Hook,详解见Logger.Hooks.Fire方法

9. func (entry *Entry) write() 
  • 功能说明:没有Hook的情况下,日志默认处理流程

  • 流程分析:
    1.使用entry.Logger.Formatter.Format格式化日志,返回一个序列化的日志数据
    2.使用entry.Logger.Out.Write写日志,系统默认Logger使用os.Stderr写日志

10. func (entry *Entry) Log(level Level, args ...interface{}) 
  • 功能说明:不同级别日志fmt.Sprint方式的通用处理方法

  • 流程分析:
    1.如果当前待写的日志级别小于Logger的级别,才会调用entry.log 2.使用fmt.Sprint格式化用户的日志

11. func (entry *Entry) Trace(args ...interface{}) 
  • 功能说明:entry的TraceLevel级别以fmt.Sprint方式写日志方法,其它级别雷同

  • 流程分析:无

12. func (entry *Entry) Logf(level Level, format string, args ...interface{}) 
  • 功能说明:不同级别日志以fmt.Sprintf方式的通用处理方法

  • 流程分析:
    1.如果当前待写的日志级别小于Logger的级别,才会调用entry.log 2.使用fmt.Sprintf格式化用户的日志

13. func (entry *Entry) Tracef(args ...interface{}) 
  • 功能说明:entry的TraceLevel级别以fmt.Sprintf方式写日志方法,其它级别雷同

  • 流程分析:无

14. func (entry *Entry) Logln(level Level, format string, args ...interface{}) 
  • 功能说明:不同级别日志以fmt.Sprintln并且没有新行的通用处理方法

  • 流程分析:
    1.如果当前待写的日志级别小于Logger的级别,才会调用entry.log 2.调用entry.sprintlnn方法,处理用户日志

15. func (entry *Entry) Traceln(args ...interface{}) 
  • 功能说明:entry的TraceLevel级别写日志方法,其它级别雷同

  • 流程分析:

15. func (entry *Entry) sprintlnn(args ...interface{}) string 
  • 功能说明:试图在每个参数之间加空格,并且去掉fmt.Sprintln多加的新行

  • 流程分析:调用fmt.Sprintln处理用户日志,然后去掉多加的新行

2.logrus.Logger结构

2.1 类型

type Logger struct {
    Out io.Writer           // Logger默认输出位置,系统默认为os.Stderr,可以设置可以更灵活,如:Kafka
                            // 使用Logger.SetOutput()方法设置
    
    Hooks LevelHooks        // 挂载在Logger上Hook集合,二维数组结构,每个日志级别对应一个Hook数组切片
                            // 类型为 type LevelHooks map[Level][]Hook,使用Logger.AddHook()添加
                            
    Formatter Formatter     // 所有日志在输出到Out上之前,都会经过formatter处理,默认为TextFormatter,
                            // 也可以设置为JSONFormatter,当输出为TTY设备,日志会用不同颜色显示,文件不行
                            // 使用Logger.SetFormatter()添加

    ReportCaller bool       // 日志是否记录调用者信息,默认关闭,可以使用Logger.SetReportCaller()设置

    Level Level             // 所有日志是否要经过默认的Out还是Hook,都有Level等级决定,默认为logrus.InfoLevel
                            // 那么只允许Info(), Warn(), Error() and Fatal()处理日志,使用Logger.SetLevel()设置
                            
    mu MutexWrap            // 互斥锁包装,默认打开,可以使用Logger.SetNoLock关闭
    
    entryPool sync.Pool     // 存放临时的Entry对象,减少GC对Entry对象的内存回收,提高Entry对象复用,提高效率
    
    ExitFunc exitFunc       // 日志退出回调函数,默认为os.Exit
} 

2.2 方法

1. func New() *Logger 
  • 功能说明:创建一个Logger对象
  • 流程分析:无,见类型说明部分
2. func (logger *Logger) newEntry() *Entry 
  • 功能说明:创建一个Entry对象

  • 流程分析:先尝试从entryPool中取一个Entry对象。若失败,调用NewEntry创建一个,并返回

3. func (logger *Logger) releaseEntry(entry *Entry) 
  • 功能说明:暂时回收Entry对象

  • 流程分析:
    1.entry.Data设置为空map,等待GC下一次运行回收
    2.将entry放入entryPool中,等待GC下一次运行回收 

4.  WithField/WithFields/WithError/WithTime 
  • 功能说明:这4个方法都是往日志中添加字段,返回一个Entry对象

  • 流程分析:
    1.先创建一个Entry对象
    2.然后分别调用Entry对象的方法,前3个方法是往Entry.Data中添加字段,WithTime是更新Entry写日志时间
    3.通过defer释放创建的Entry对象

5. func (logger *Logger) Logf(level Level, format string, args ...interface{}) 
  • 功能说明:以fmt.Sprintf格式写日志

  • 流程分析:
    1.若level <= logger.Level,才会处理日志 2.newEntry创建entry对象 3.entry.Logf()处理日志 4.releaseEntry回收entry对象

6. Tracef/Debugf/Infof/Printf/Warnf/Warningf/Errorf/Fatalf 
  • 功能说明:以fmt.Sprintf格式格式化用户日志,并写入对应级别的日志

  • 流程分析:

7. func (logger *Logger) Log(level Level, args ...interface{}) 
  • 功能说明:以fmt.Sprint格式写日志

  • 流程分析:
    1.若level <= logger.Level,才会处理日志 2.newEntry创建entry对象 3.entry.Log()处理日志 4.releaseEntry回收entry对象

8. Trace/Debug/Info/Print/Warn/Warning/Error/Fatal 
  • 功能说明:以fmt.Sprint格式格式化用户日志,并写入对应级别的日志

  • 流程分析: 

9. func (logger *Logger) Logln(level Level, args ...interface{}) 
  • 功能说明:不同级别日志以fmt.Sprintln,并且没有新行的通用处理方法

  • 流程分析:
    1.若level <= logger.Level,才会处理日志 2.newEntry创建entry对象 3.entry.Log()处理日志 4.releaseEntry回收entry对象

10. Traceln/Debugln/Infoln/Println/Warnln/Warningln/Errorln/Fatalln 
  • 功能说明:以不同级别的方式使用Logln写入日志

  • 流程分析: 

3.logrus.Hook结构

1.1 类型

type Hook interface {
	Levels() []Level        // 当前Hook可有效用于哪些级别的日志
	Fire(*Entry) error      // 当前Hook处理方法,将被LevelHooks.Fire方法执行
}

type LevelHooks map[Level][]Hook    // 每级日志对应一个Hook数组,有的写入本地磁盘,有的输送到日志服务器上,有的...

Hook是一个接口,每一个用户自定义的Hook,都必须实现Levels()方法和Fire()方法,

用户可以封装复杂的结构及方法,实现Hook接口,通过Fire()可以将特定格式的日志数据,记录到特定的目的地。
可参考:github.com/rifflock/lfshook、gopkg.in/sohlich/elogrus.v2、github.com/pkg/logrus_amqp 

1.2 方法

1. func (hooks LevelHooks) Add(hook Hook) 
  • 功能说明:给不同级别日志Hook列表中添加Hook,这些级别由用户实现的Hook.Levels()方法决定

  • 流程分析:以下是Add()方法代码

      for _, level := range hook.Levels() {
          hooks[level] = append(hooks[level], hook)
    

    循环往Levels()对应的Level列表中,分别添加Hook

2. func (hooks LevelHooks) Fire(level Level, entry *Entry) error 
  • 功能说明:处理level级别下所有Hook

  • 流程分析:以下是Fire()方法代码

      for _, hook := range hooks[level] {
          if err := hook.Fire(entry); err != nil {
              return err
          }
      }

    循环处理level对应的hooks列表中的hook,调用每个hook中用户实现的Fire方法,并传入当前logging的entry对象

      * Hook接口:
      Levels()    决定当前Hook将作用于哪些级别的日志
      Fire()      处理当前日志的用户自定义回调处理方法
      
      * LevelHooks结构:
      type LevelHooks map[Level][]Hook,图示如下:
      
      PanicLevel  --> hook1 | hook2 | hook3 | hook4 | hook5 
      FatalLevel  --> hook2 | hook3 | hook4 | hook5   
      ErrorLevel  --> hook2 | hook3 | hook5 
      WarnLevel   --> hook4 | hook5
      InfoLevel   --> hook3
      DebugLevel  --> hook2
      TraceLevel  --> hook2 | hook4
      
      * LevelHooks方法集:
      Add(hook)           给不同级别日志Hook列表中添加hook,这些级别由hook.Levels()决定
      Fire(level, entry)  处理level对应的hook列表中的所有hook,即调用它们各自的Fire()方法    

4.Entry与Logger的关系

  • Entry是每条日志记录的实体,每记录一条日志,都会创建一个Entry对象,里面包含具体日志记录的数据字段和方法集。包括:
    Message(用户记录原始数据),Time(日志时间),Level(记录级别),Data(自定义格式字段),Caller(运行时调用者信息),
    Buffer(经过Logger.Formatter处理后的序列化数据),err(日志记录出错记录),Logger(当前Entry所属的Logger)。

  • Logger是一个全局日志工具,包含:
    Out(默认日志记录的Writer),Hooks(Hook机制),Formatter(默认日志记录的格式化器),
    ReportCaller(默认日志记录,记录运行时调用者信息的开关),Level(所有日志记录的过滤级别,包括所有添加的Hook),
    mu(Logger操作互斥锁), entryPool(Entry对象缓冲池),ExitFunc(退出应用程序处理函数,默认为os.EXIT())。

  • 所有记录日志的上层操作接口是由Logger提供,Entry属于后台记录的实体,Logger每提交一条日志,都对应一个Entry对象,并最后交由它处理。

  • Logger可以高度定制,使用Hook钩子机制,可以做到多级别输出、格式化输出、多样化输出(不同输出目的地)。

阅读(6608) | 评论(0) | 转发(0) |
0

上一篇:Python学习之装饰器@用法

下一篇:没有了

给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册