1. 日志处理

beego 之前介绍的时候说过是基于几个模块搭建的，beego 的日志处理是基于 logs 模块搭建的，内置了一个变量 BeeLogger，默认已经是 logs.BeeLogger 类型，初始化了 console，也就是默认输出到 console。

1.1. 使用入门

一般在程序中我们使用如下的方式进行输出：

  1. beego.Emergency("this is emergency")
  2. beego.Alert("this is alert")
  3. beego.Critical("this is critical")
  4. beego.Error("this is error")
  5. beego.Warning("this is warning")
  6. beego.Notice("this is notice")
  7. beego.Informational("this is informational")
  8. beego.Debug("this is debug")

1.2. 设置输出

我们的程序往往期望把信息输出到 log 中，现在设置输出到文件很方便，如下所示：

  1. beego.SetLogger("file", `{"filename":"logs/test.log"}`)

更多详细的日志配置请查看日志配置

这个默认情况就会同时输出到两个地方，一个 console，一个 file，如果只想输出到文件，就需要调用删除操作：

  1. beego.BeeLogger.DelLogger("console")

1.3. 设置级别

日志的级别如上所示的代码这样分为八个级别：

  1. LevelEmergency
  2. LevelAlert
  3. LevelCritical
  4. LevelError
  5. LevelWarning
  6. LevelNotice
  7. LevelInformational
  8. LevelDebug

级别依次降低，默认全部打印，但是一般我们在部署环境，可以通过设置级别设置日志级别：

  1. beego.SetLevel(beego.LevelInformational)

1.4. 输出文件名和行号

日志默认不输出调用的文件名和文件行号,如果你期望输出调用的文件名和文件行号,可以如下设置

  1. beego.SetLogFuncCall(true)

开启传入参数 true, 关闭传入参数 false, 默认是关闭的.

1.5. 完整示例

  1. func internalCalculationFunc(x, y int) (result int, err error) {
  2.     beego.Debug("calculating z. x:", x, " y:", y)
  3.     z := y
  4.     switch {
  5.     case x == 3:
  6.         beego.Debug("x == 3")
  7.         panic("Failure.")
  8.     case y == 1:
  9.         beego.Debug("y == 1")
  10.         return 0, errors.New("Error!")
  11.     case y == 2:
  12.         beego.Debug("y == 2")
  13.         z = x
  14.     default:
  15.         beego.Debug("default")
  16.         z += x
  17.     }
  18.     retVal := z - 3
  19.     beego.Debug("Returning ", retVal)
  21.     return retVal, nil
  22. }
  24. func processInput(input inputData) {
  25.     defer func() {
  26.         if r := recover(); r != nil {
  27.             beego.Error("Unexpected error occurred: ", r)
  28.             outputs <- outputData{result: 0, error: true}
  29.         }
  30.     }()
  31.     beego.Informational("Received input signal. x:", input.x, " y:", input.y)
  33.     res, err := internalCalculationFunc(input.x, input.y)
  34.     if err != nil {
  35.         beego.Warning("Error in calculation:", err.Error())
  36.     }
  38.     beego.Informational("Returning result: ", res, " error: ", err)
  39.     outputs <- outputData{result: res, error: err != nil}
  40. }
  42. func main() {
  43.     inputs = make(chan inputData)
  44.     outputs = make(chan outputData)
  45.     criticalChan = make(chan int)
  46.     beego.Informational("App started.")
  48.     go consumeResults(outputs)
  49.     beego.Informational("Started receiving results.")
  51.     go generateInputs(inputs)
  52.     beego.Informational("Started sending signals.")
  54.     for {
  55.         select {
  56.         case input := <-inputs:
  57.             processInput(input)
  58.         case <-criticalChan:
  59.             beego.Critical("Caught value from criticalChan: Go shut down.")
  60.             panic("Shut down due to critical fault.")
  61.         }
  62.     }
  63. }