logrus日志框架

目录

  • logrus介绍
  • logrus配置
  • 日志打印
  • HOOK机制
  • Gin日志
  • Fatal处理
  • 线程安全

logrus介绍

golang标准库的日志框架非常简单,仅仅提供了print,panic和fatal三个函数。对于更精细的日志级别、日志文件分割,以及日志分发等方面,并没有提供支持。在golang的世界,流行的日志框架包括logrus、zap、zerolog、seelog等。

logrus配置

1. 日志级别: logrus有7个日志级别,依次是Trace << Debug << Info << Warning << Error << Fatal << Panic

//  只输出不低于当前级别是日志数据
logrus.SetLevel(logrus.DebugLevel)

2. 日志格式: logrus内置了JSONFormatterTextFormatter两种格式,也可以通过Formatter接口定义日志格式

 // TextFormatter格式
 logrus.SetFormatter(&logrus.TextFormatter{
    ForceColors:               true,
    EnvironmentOverrideColors: true,
    TimestampFormat:           "2006-01-02 15:04:05", //时间格式
    // FullTimestamp:true,
    // DisableLevelTruncation:true,
 })
 // JSONFormatter格式
 logrus.SetFormatter(&logrus.JSONFormatter{
    PrettyPrint:     false,                 //格式化
    TimestampFormat: "2006-01-02 15:04:05", //时间格式
 })

3. 输出文件:

 logfile, _ := os.OpenFile("./app.log", os.O_CREATE|os.O_RDWR|os.O_APPEND, 0644)
 logrus.SetOutput(logfile) //默认为os.stderr

4. 日志定位: 定位行号(如:func=main.main file="./xxx.go:38"

logrus.SetReportCaller(true)

示例:

func init() {
   logrus.SetLevel(logrus.DebugLevel)

   logrus.SetFormatter(&logrus.JSONFormatter{
      TimestampFormat: "2006-01-02 15:04:05",
   })

   logfile, _ := os.OpenFile("./app.log", os.O_CREATE|os.O_RDWR|os.O_APPEND, 0644)
   logrus.SetOutput(logfile) //默认为os.stderr
}

//方式一:logrus函数(最终调用的是logrus.StandardLogger默认实例方法)
func main() {
   logrus.Infoln("测试数据")
}

日志打印

FieldLogger接口: FieldLogger定义了所有日志打印的方法

type FieldLogger interface {
   WithField(key string, value interface{}) *Entry
   WithFields(fields Fields) *Entry
   WithError(err error) *Entry

   Debugf(format string, args ...interface{})
   Infof(format string, args ...interface{})
   Printf(format string, args ...interface{})
   Warnf(format string, args ...interface{})
   Warningf(format string, args ...interface{})
   Errorf(format string, args ...interface{})
   Fatalf(format string, args ...interface{})
   Panicf(format string, args ...interface{})

   Debug(args ...interface{})
   Info(args ...interface{})
   Print(args ...interface{})
   Warn(args ...interface{})
   Warning(args ...interface{})
   Error(args ...interface{})
   Fatal(args ...interface{})
   Panic(args ...interface{})

   Debugln(args ...interface{})
   Infoln(args ...interface{})
   Println(args ...interface{})
   Warnln(args ...interface{})
   Warningln(args ...interface{})
   Errorln(args ...interface{})
   Fatalln(args ...interface{})
   Panicln(args ...interface{})
}

日志打印1: 默认实例 (函数),即通过logrus包提供的函数(覆盖了FieldLogger接口的所有方法),直接打印日志。但其实logrus包函数是调用了logrus.Loger默认实例。

// 直接调用包函数
func main() {
   logrus.Infoln("...")
   logrus.Errorln("...")
   // ...
}

日志打印2:Logger实例(对象),它实现了FieldLogger接口。

func main() {
   //var loger = logrus.StandardLogger()
   var loger = logrus.New()
   loger.Formatter = &logrus.JSONFormatter{TimestampFormat: "2006-01-02 15:04:05"}
   loger.Infoln("可以创建任意数量的logrus实例")
}

日志打印3:Entry示例(对象),它也实现了FieldLogger接口,是最终是日志打印入口。

  • 这里用到了Field机制,logrus鼓励通过Field机制进行精细化的、结构化的日志记录,而不是通过冗长的消息来记录日志。
func main() {
   logrus.SetFormatter(&logrus.JSONFormatter{TimestampFormat: "2006-01-02 15:04:05"})

   // Entry实例
   entry := logrus.WithFields(logrus.Fields{
      "global": "全局字段",
   })

   entry.WithFields(logrus.Fields{"module": "用户模块"}).
      Info("测试ok")
}

HOOK机制

  • hook即钩子,拦截器。它为logrus提供了强大的功能扩展,如将日志分发到任意地方,如本地文件系统、logstashes等,或者切割日志、定义日志内容和格式等。hook接口原型如下:
type Hook interface {
   Levels() []Level   //日志级别
   Fire(*Entry) error //打印入口(Entry对象)
}

Hook - 日志切割:

import (
   "github.com/lestrrat-go/file-rotatelogs"
   "github.com/rifflock/lfshook"
   "github.com/sirupsen/logrus"
   "time"
)

//  说明:按时间切割日志文件(2秒创建一个日志文件)
func main() {
   hook := NewLfsHook("app_hook", time.Second*2, 5)
   logrus.AddHook(hook)

   logrus.Infoln("测试开始")
   log := logrus.WithFields(logrus.Fields{"module": "用户模块"})

   for i := 0; i < 10; i++ {
      log.Infoln("成功", i)
      time.Sleep(time.Second)
   }
}

// 日志钩子(日志拦截,并重定向)
func NewLfsHook(logName string, rotationTime time.Duration, leastDay uint) logrus.Hook {
   writer, err := rotatelogs.New(
      // 日志文件
      logName+".%Y%m%d%H%M%S",

      // 日志周期(默认每86400秒/一天旋转一次)
      rotatelogs.WithRotationTime(rotationTime),

      // 清除历史 (WithMaxAge和WithRotationCount只能选其一)
      //rotatelogs.WithMaxAge(time.Hour*24*7), //默认每7天清除下日志文件
      rotatelogs.WithRotationCount(leastDay), //只保留最近的N个日志文件
   )
   if err != nil {
      panic(err)
   }

   // 可设置按不同level创建不同的文件名
   lfsHook := lfshook.NewHook(lfshook.WriterMap{
      logrus.DebugLevel: writer,
      logrus.InfoLevel:  writer,
      logrus.WarnLevel:  writer,
      logrus.ErrorLevel: writer,
      logrus.FatalLevel: writer,
      logrus.PanicLevel: writer,
   }, &logrus.JSONFormatter{TimestampFormat: "2006-01-02 15:04:05"})

   return lfsHook
}

Hook - Redis重定向: 即将日志输出到redis

import (
   logredis "github.com/rogierlommers/logrus-redis-hook"
   "io/ioutil"
   "github.com/sirupsen/logrus"
)

func init() {
   hookConfig := logredis.HookConfig{
      Host:     "localhost",
      Key:      "test",
      Format:   "v1",
      App:      "my_app_name",
      Port:     6379,
      Hostname: "my_app_hostname",
      DB:       0, // optional
      TTL:      3600,
   }

   hook, err := logredis.NewHook(hookConfig)
   if err == nil {
      logrus.AddHook(hook)
   } else {
      logrus.Errorf("logredis error: %q", err)
   }
}

func main() {
   logrus.WithFields(logrus.Fields{
      "module": "user"}).
      Info("user login")

   // If you want to disable writing to stdout, use setOutput
   logrus.SetOutput(ioutil.Discard)
   logrus.Info("log to Redis")
}

// 测试:
// 1.启动redis服务: redis-server
// 2.监控redis数据: redis-cli monitor

其他Hook:

Gin日志

  • 将gin框架的日志定向到logrus日志文件
func init() {
   // 输出格式
   logrus.SetFormatter(&logrus.JSONFormatter{TimestampFormat: "2006-01-02 15:04:05"})

   // 输出路径
   logfile, _ := os.OpenFile("./app.log", os.O_CREATE|os.O_RDWR|os.O_APPEND, 0644)
   logrus.SetOutput(logfile)

   // Gin日志重定向
   gin.DisableConsoleColor()                              //不需要颜色
   gin.DefaultWriter = io.MultiWriter(os.Stdout, logfile) //os.Stdout
}

//测试:curl 0.0.0.0:8080/index
func main() {
   log := logrus.WithFields(logrus.Fields{
      "module": "用户模块",
   })

   r := gin.Default()
   r.GET("/index", func(c *gin.Context) {
      log.Warnln("gin日志数据")
      c.String(200, "ok")
   })
   _ = r.Run()
}

Fatal处理

  • logrus的Fatal输出,会执行os.Exit(1)。logrus提供RegisterExitHandler方法,可以在系统异常时调用一些资源释放api等,让应用正确地关闭。
func main() {
   logrus.RegisterExitHandler(func() {
      fmt.Println("发生了fatal异常,执行关闭文件等工作")
   })

   logrus.Warnln("warn测试")
   logrus.Fatalln("fatal测试")
   logrus.Infoln("info测试") //不会执行
}

线程安全

  • 默认情况下,logrus的api都是线程安全的,其内部通过互斥锁来保护并发写。互斥锁在调用hooks或者写日志的时候执行。如果不需要锁,可以调用logger.SetNoLock()来关闭之。
    可以关闭logrus互斥锁的情形包括:
  • 没有设置hook,或者所有的hook都是线程安全的实现。
  • 写日志到logger.Out已经是线程安全的了。例如,logger.Out已经被锁保护,或者写文件时,文件是以O_APPEND方式打开的,并且每次写操作都小于4k。

参考

https://blog.csdn.net/wslyk606/article/details/81670713

原文地址:https://www.cnblogs.com/Hollson/p/12169224.html

时间: 2024-10-06 01:18:48

logrus日志框架的相关文章

Java 日志框架终极教程

概述 对于现代的 Java 应用程序来说,只要被部署到真实的生产环境,其日志的重要性就是不言而喻的,很难想象没有任何日志记录功能的应用程序被运行于生产环境中.日志 API 所能提供的功能是多种多样的,包括记录程序运行时产生的错误信息.状态信息.调试信息和执行时间信息等.在生产环境中,日志是查找问题来源的重要依据,应用程序运行时的产生的各种重要信息,都应该通过日志 API 来进行记录. 很多Java开发人员习惯于使用 System.out.println.System.err.println 以及

配置日志框架——Log4j

Log4j作为一个开源的优秀日志框架,被广泛使用,Hibernate和MyBatis都是支持Log4j的,我们只需要引入Log4j的jar包即可. Log4j.properties文件 log4j.rootLogger=info,appender1,appender2 //appender1,appender2这是输出的目标地址,当然可以有多个,在这里只写了两个 log4j.appender.appender1=org.apache.log4j.ConsoleAppender //指定输出类型,

Java-最常用的Java日志框架整理

前言 Java程序员,我们开发了很多Java应用程序,包括桌面应用.WEB应用以及移动应用.然而日志系统是一个成熟Java应用所必不可少的,在开发和调试阶段,日志可以帮助我们更好更快地定位bug:在运行维护阶段,日志系统又可以帮我们记录大部分的异常信息,从而帮助我们更好的完善系统.本文要来分享一些Java程序员最常用的Java日志框架组件.1.log4j – 最受欢迎的Java日志组件 Log4j是一款基于Java的开源日志组件,Log4j功能非常强大,我们可以将日志信息输出到控制台.文件.用户

Java程序员最常用的8个Java日志框架

1.Log4j – 最受欢迎的Java日志组件 Log4j是一款基于Java的开源日志组件,Log4j功能非常强大,我们可以将日志信息输出到控制台.文件.用户界面,也可以输出到操作系统的事件记录器和一些系统常驻进程.更值得一提的是,Log4j可以允许你非常便捷地自定义日志格式和日志等级,可以帮助开发人员全方位地掌控日志信息. 官方网站:http://logging.apache.org/log4j/2.x/ 下面是使用Log4j的一个简单例子: 2.gclogviewer – Java日志查看工

Spring集成Log4j日志框架

1.日志系统介绍 slf4j,即简单日志门面(Simple Logging Facade for Java),不是具体的日志解决方案,它只服务于各种各样的日志系统.简答的讲就是slf4j是一系列的日志接口,而log4j是具体实现了的日志框架. slf4j与常用日志框架绑定关系,图片来源 2.Maven导入slf4j和log4j,编辑pom.xml <!-- 导入slf4j-log4j12,依赖slf4j-api和log4j,自动导入 --> <dependency> <gro

一个简单好用的日志框架NLog

之前我介绍过如何使用log4net来记录日志,但最近喜欢上了另一个简单好用的日志框架NLog. 关于NLog和log4net的比较这里就不多讨论了,感兴趣的朋友可以参看.NET日志工具介绍和log4net vs. Nlog这两篇文章.本文主要介绍一下如何在项目中使用NLog. 在Nuget中安装NLog NLog可以直接使用Nuget安装: PM > Install-Package Nlog 使用NLog NLog的使用方式基本上和其它的Log库差不多,分为Trace.Debug.Info.Er

C/C++/C#/Python日志框架

俗话说,打得一手好log才是一个优秀的程序员. **打log的目的是为了迅速排错或在有争议时拿出证据证明自己.基于这个目的,log不在多,只要抓住一切对自己有利的信息,就可以了.** 日志框架列表 C/C++      spdlog  只需要引用头文件就可以了 C#      NLog  第三方库,性能比log4net好,支持跨平台 python       logging  自带模块

Node.js日志框架选型比較:Winston

日志对于问题定位.调试,系统性能调优至关重要,尤其是系统复杂以及在线执行的情况下. 好的开发框架都会有一个可开启关闭/可配置记录级别的日志系统.我们从下面几个方面来做选型: 1. 每行日志都须要有准确无误的时间戳 2. 日志格式easy被人理解同一时候也easy被计算机进行分析处理 3. 同意配置不同的日志输出,比方对于不同级别的日志配置不同的处理方式 基于上述的要求,有两款Node.js框架脱颖而出,各自是Bunyan和Winston. Bunyan by Trent Mick. Winsto

log4j日志框架学习

初识Log4j: log4j有三个部分: 1.loggers 负责捕获日志信息. 2.appenders  负责输出信息到不同的目的地 3.layouts 负责使用不同的样式输出日志 log4j框架中有两种对象: 核心对象:框架的支撑对象,是框架必不可少的组成部分. 支撑对象:这些都是框架可选的对象,用于提供额外重要的工作. 核心对象包括下面几种类型: logger对象,是最高的层,负责通过不同的风格转化日志信息,他提供给appender对象发布前的信息.(这里的层是指所处的位置) layout