go第三方日志系统-seelog-Basic sections

https://github.com/cihub/seelog

文档学习：https://github.com/cihub/seelog/wiki

1.安装：

go get github.com/cihub/seelog

2.快速启动

Seelog的设计非常方便。它的默认配置和包级别的日志记录器是现成的，所以开始你只需要两行代码:

package main

import log "github.com/cihub/seelog"

func main() {
    defer log.Flush()
    log.Info("Hello from Seelog!")
}

Info只是Seelog支持的日志级别之一。你还可以使用Trace, Debug, Info, Warn, Error, Critical级别。

运行返回：

bogon:~ user$ go run testGo.go
 [Info] Hello from Seelog!

基本配置

这是seelog config的一个例子，它使用默认格式选项、约束等将输出重定向到控制台，命名为seelog.xml。

<seelog>
    <outputs>
        <console />
    </outputs>
</seelog>

大多数wiki部分介绍使用configs进行的Seelog调优。

下载配置
在Seelog包中有几个函数可以帮你加载configs。

logger, err := log.LoggerFromConfigAsFile("seelog.xml")

if err != nil {
    return err
}

log.ReplaceLogger(logger)

这里还有'LoggerFromConfigAsBytes',和'LoggerFromConfigAsString'两种类型的下载函数

你可以在任何时候运行log.ReplaceLogger。配置转换可见Changing config on the fly

defer块和刷新

在许多情况下，无法在主goroutine中处理生成的日志信息。

在这些情况下，我们建议异步日志记录器在非阻塞模式下依次从队列中接收缓冲消息。在这种情况下，确保在应用程序遭受紧急崩溃时不会丢失日志数据是至关重要的。我们在main函数的defer中使用log. Flush()函数解决了这个问题，它保证日志消息队列中剩下的所有消息都将正常地独立于应用程序不管panic是否进行处理。

注意:在使用Seelog构造之前，defer块必须放在可执行文件的main函数中。在编写包时，不要担心延迟刷新，详情可见Writing libraries with Seelog

ReplaceLogger 和 UseLogger

这两个函数都更改了负责当前日志记录器的包级别变量。此变量用于包级函数“Trace”、“Debug”等。但是，请注意区别。

前者正确地关闭前一个日志记录器(使用刷新日志数据)，然后用一个新的日志记录器替换它。当你更改日志配置时，这是最推荐的方法。

后者只刷新前一个日志记录器(不关闭它)，然后用一个新的日志记录器替换它。当你更改日志记录器并且对关闭旧日志记录器漠不关心时，应该使用此方法。

演示配置的所有功能

有一个演示配置，它在一个地方演示了大多数功能，可见下面的 9.Example config

你可以在深入研究所有特性之前检查它。

3.日志级别

这一节展示了我们对Seelog级别层次、它们的含义和使用范围的看法。当我们根据自己的概念对Seelog代码进行调优时，建议遵循以下规则。

支持的日志级别有：

• Trace -查找关于所有基本构造的状态的普遍信息。使用“Trace”进行深度调试，查找函数的问题部分，检查临时变量的值，等等。
• Debug——用于详细的系统行为报告和诊断消息，以帮助定位开发过程中的问题。
• Info-关于应用程序工作的一般信息。在代码中使用“Info”级别，这样即使在生产环境中也可以启用它。所以这是一个“生产日志级别”。
• Warn-用于指示以安全方式自动处理的小错误、奇怪情况和故障。
• Error-严重故障影响应用程序的工作流程，但不是致命的(不强迫应用程序关闭)。
• Critical——在应用程序死亡之前生成最后的消息。注意:Critical消息强制立即刷新，因为Critical情况下，如果应用程序崩溃，避免日志消息丢失是很重要的。
• Off—用于关闭日志记录的特殊日志级别

配置文件的日志级别标识符

• "trace"——低级别
• "debug"
• "info"
• "warn"
• "error"
• "critical"——高级别

日志消息示例

• Trace
  • "Entered parse function validation block"
  • "Validation: entered second 'if'"
  • "Dictionary 'Dict' is empty. Using default value"
• Debug
  • "Web page requested: http://somesite.com Params='...'"
  • "Response generated. Response size: 10000. Sending."
  • "New file received. Type:PNG Size:20000"
• Info
  • "Web server restarted"
  • "Hourly statistics: Requested pages: 12345 Errors: 123 ..."
  • "Service paused. Waiting for 'resume' call"
• Warn
  • "Cache corrupted for file='test.file'. Reading from back-end"
  • "Database 192.168.0.7/DB not responding. Using backup 192.168.0.8/DB"
  • "No response from statistics server. Statistics not sent"
• Error
  • "Internal error. Cannot process request #12345 Error:...."
  • "Cannot perform login: credentials DB not responding"
• Critical
  • "Critical panic received: .... Shutting down"
  • "Fatal error: ... App is shutting down to prevent data corruption or loss"

例子：

下面的示例演示了Seelog级别的概念用法。

注1:这个例子实际上在计算方面没有任何意义。它只是突出了日志级别使用上下文中的差异。

注2:有时人们会将Info与Debug甚至Trace混淆。我们试图找出最引人注目的案例。请注意“Info”用例:它是一个生产日志级别，我们让它在不影响性能(即使在生产中)的情况下运行。

package main

import (
    log "github.com/cihub/seelog"
    "time"
    "errors"
)

type inputData struct {
    x, y int
}

type outputData struct {
    result int
    error bool
}

var inputs chan inputData
var outputs chan outputData
var criticalChan chan int

func internalCalculationFunc(x, y int) (result int, err error) {
    log.Debugf("calculating z. x:%d y:%d", x, y) //报告系统行为，定位开发过程
    z := y
    switch {
    case x ==  :
        log.Trace("x == 3")//进行深度调试：查找函数的问题部分，检查临时变量的值等
        panic("Failure.")
    case y ==  :
        log.Trace("y == 1")
        return , errors.New("Error!")
    case y ==  :
        log.Trace("y == 2")
        z = x
    default :
        log.Trace("default")
        z += x
    }
    log.Tracef("z:%d",z)
    retVal := z-
    log.Debugf("Returning %d", retVal)

    return retVal, nil
}

func generateInputs(dest chan inputData) {
    time.Sleep(1e9)
    log.Debug("Sending 2 3")
    dest <- inputData{x : , y : }

    time.Sleep(1e9)
    log.Debug("Sending 2 1")
    dest <- inputData{x : , y : }

    time.Sleep(1e9)
    log.Debug("Sending 3 4")
    dest <- inputData{x : , y : }

    time.Sleep(1e9)
    log.Debug("Sending critical")
    criticalChan <-
}

func consumeResults(res chan outputData) {
    for {
        select {
            case <- outputs:
            //在这一点上，我们得到并输出结果值
        }
    }
}

func processInput(input inputData) {
    defer func() {
        if r := recover(); r != nil {//获取panic中的错误信息
            log.Errorf("Unexpected error occurred: %v", r) //记录错误信息
            outputs <- outputData{result : , error : true}
        }
    }()
    log.Infof("Received input signal. x:%d y:%d", input.x, input.y)    //关于应用程序工作的一般信息

    res, err := internalCalculationFunc(input.x, input.y)
    if err != nil {
        log.Warnf("Error in calculation: %s", err.Error())//用于指示以安全方式自动处理的小错误、奇怪情况和故障
    }

    log.Infof("Returning result: %d error: %t", res, err != nil)
    outputs <- outputData{result : res, error : err != nil}
}

func main() {
    inputs = make(chan inputData)
    outputs = make(chan outputData)
    criticalChan = make(chan int)
    log.Info("App started.")

    go consumeResults(outputs) //outputs通道等待结果，并将结果输出
    log.Info("Started receiving results.")

    go generateInputs(inputs)
    log.Info("Started sending signals.")//三次将值发送到inputs通道中，并输入1给criticalChan

    for {
        select {
            case input := <- inputs: //generateInputs每次值输入到inputs时就并发在此输出
                processInput(input) //进行内部计算并将结果输入通道outputs
            case <- criticalChan:  //直到generateInputs的最后输入1给criticalChan
                log.Critical("Caught value from criticalChan: Go shut down.") //在应用程序死亡之前生成最后的消息
                panic("Shut down due to critical fault.")
        }
    }
}

返回：

bogon:~ user$ go run testGo.go
 [Info] App started.
 [Info] Started receiving results.
 [Info] Started sending signals.
 [Debug] Sending
 [Info] Received input signal. x: y:
 [Debug] calculating z. x: y:
 [Trace] default
 [Trace] z:
 [Debug] Returning
 [Info] Returning result:  error: false
 [Debug] Sending
 [Info] Received input signal. x: y:
 [Debug] calculating z. x: y:
 [Trace] y ==
 [Warn] Error in calculation: Error!
 [Info] Returning result:  error: true
 [Debug] Sending
 [Info] Received input signal. x: y:
 [Debug] calculating z. x: y:
 [Trace] x ==
 [Error] Unexpected error occurred: Failure.
 [Debug] Sending critical
 [Critical] Caught value from criticalChan: Go shut down.
panic: Shut down due to critical fault.

goroutine  [running]:
main.main()
    /Users/user/testGo.go: +0x3bc
exit status 

4.约束和例外

限制

约束限制了规范日志级别的规则。如果没有指定约束，则允许所有日志级别。

• Min/max约束允许包含最小值和最大值之间的级别(例如，info thru error)。min和max都不需要在场。因此，你可以允许所有日志级别高于或低于最小级别1。可使用关键字“minlevel”和“maxlevel”设置这些约束。
• 约束列表只允许在列表中指定级别。例如，你可以输入字符串“debug, info, critical”来表示logger需要这三个级别。使用关键字“levels”来设置这种约束。

有两种类型的约束:全局约束和例外约束

全局约束

全局约束用于整个应用程序，它们使用的是“定期应用的”规则(而不是“例外”)。这些约束是在seelog根元素属性中设置的。

举例说明

若要只允许日志级别“info”及以上，请使用以下命令启动配置:

<seelog minlevel="info">

允许级别从 info到error(即 info, warn, error)，使用:

<seelog minlevel="info" maxlevel="error">

要只允许特定的级别集(例如trace, info, and critical级别)，请使用以下命令启动配置:

<seelog levels="trace,info,critical">

例外约束

例外，与一般规则相反，被认为是打破(放松或加强)常规规则(一般约束)的特殊情况。例如，你可能希望限制特定文件或文件组的日志记录。反之亦然:你确实有限制全局约束，并且你希望允许特定的文件或函数在更深的层次上进行日志记录。

例外包括“filepattern”、“funcpattern”和约束(“minlevel”/“maxlevel”或“levels”)。因此，如果你希望使用特定的名称模式覆盖函数或文件(或两者)的一般规则，那么可以在“filepattern”/“funcpattern”字段中指定模式，并使用覆盖约束。

例外如何使用

当你在运行时为每个日志执行日志记录时。在底层调用调用方函数以获取当前上下文。然后我们发现匹配模式file/func名的第一个例外。如果发现这样的例外，则其约束将覆盖常规约束。

建议

根据上面所说的，有一些简单的建议:

• 例外要适度。当我们在每次记录某样东西时都运行例外列表时，用规则填充它不是一个好主意，只有少数可以这么做。我们称它们为例外是有原因的!
• 避免生产配置中允许“trace”或“debug”级别的约束。如果这样做，你将告诉分析器“允许在某些地方进行traces/debugs”，并且所有Trace/Debug调用不会立即返回，而是强制约束检查器在每次运行时运行。然后调用者将进入例外列表等。然而，对于性能并不重要的开发或生产系统，这些限制是可以接受的。(参见下面的例子)
• 首先使用更具体的规则。这只是因为我们恰好使用满足file/func名称模式的第一个例外。因此，如果你的文件名符合例外的“filepattern”—例外子系统将立即使用此例外的约束，而不会查看随后出现的例外。所以首先使用更具体的规则，最后使用不那么具体的规则(参见下面的例子)

举例说明：

让我们从“test”开始，为所有文件创建更多的限制规则。

<seelog minlevel="info">
    <exceptions>
        <exception filepattern="test*" minlevel="error"/>
    </exceptions>

通过这种方式，你将获得所有文件的“info”、“warn”、“error”、“critical”消息，但以“test”开头的文件除外。对于以“test”开头的文件，你只会得到“error”和“critical”消息。

另一个例子。现在让我们创建一个相反的情况:让我们只允许“critical”消息作为一般规则，但允许“main.testFunc”函数为“warn, error, critical”级别(package 'main'， func 'testFunc'):

<seelog levels="critical">
    <exceptions>
        <exception funcpattern="main.testFunc" minlevel="warn"/>
    </exceptions>

让我们创建一个生产就绪配置:

<seelog minlevel="info">
    <exceptions>
        <exception funcpattern="main.testFunc" minlevel="warn"/>
                <exception funcpattern="main.testFunc2" minlevel="error"/>
                <exception funcpattern="*test*" filepattern="tests.go" levels="off"/>
                <exception funcpattern="*perfCritical" minlevel="critical"/>
    </exceptions>
...

这个配置完全可以用于生产，因为它没有任何允许级别“trace”或“debug”的例外
让我们先测试一下“更常见的例外情况”规则:

<seelog minlevel="info">
    <exceptions>
                <exception funcpattern="main.testFunc" levels="critical"/>
                <exception funcpattern="main.test*" minlevel="error"/>
        <exception funcpattern="main.*" minlevel="warn"/>
    </exceptions>
...

这个配置将像它看起来的那样工作。但如果你以另一种顺序写这些例外，它就不一样了。例如，如果你将“main.*”放在例外的前面，那么其他两个例外将被忽略。

“off”日志级别

“off”是一个特殊的日志级别，它意味着禁用日志记录。它可以在minlevel和level约束中使用，因此你可以在全局约束或例外约束中写入'minlevel= “off”'和'levels= “off”'来禁用日志。

示例

package main

import (
    "fmt"
    log "github.com/cihub/seelog"
)

func main() {
    defer log.Flush()
    testMinMax()
    testMin()
    testMax()
    testList()
    testFuncException()
    testFileException()
}

func testMinMax() { //只会输出日志级别在info和error之间的日志的内容，即info\warn\error
    fmt.Println("testMinMax")
    testConfig := `
<seelog type="sync" minlevel="info" maxlevel="error">
    <outputs><console/></outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("NOT Printed")
    log.Debug("NOT Printed")
    log.Info("Printed")
    log.Warn("Printed")
    log.Error("Printed")
    log.Critical("NOT Printed")
}

func testMin() { //会输出大于info日志级别的日志内容，即info\warn\error\critical
    fmt.Println("testMin")
    testConfig := `
<seelog type="sync" minlevel="info">
    <outputs><console/></outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("NOT Printed")
    log.Debug("NOT Printed")
    log.Info("Printed")
    log.Warn("Printed")
    log.Error("Printed")
    log.Critical("Printed")
}

func testMax() {//会输出级别不大于error的日志文件的信息，即trace、debug、info、warn和error
    fmt.Println("testMax")
    testConfig := `
<seelog type="sync" maxlevel="error">
    <outputs><console/></outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Printed")
    log.Debug("Printed")
    log.Info("Printed")
    log.Warn("Printed")
    log.Error("Printed")
    log.Critical("NOT Printed")
}

func testList() {//只输出日志级别为info, trace, critical的日志
    fmt.Println("testList")
    testConfig := `
<seelog type="sync" levels="info, trace, critical">
    <outputs><console/></outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Printed")
    log.Debug("NOT Printed")
    log.Info("Printed")
    log.Warn("NOT Printed")
    log.Error("NOT Printed")
    log.Critical("Printed")
}

//主限制是输出大于info日志级别的日志内容，
//但是这里有个例外，要求满足函数名为"*main.test*Except*"的函数中的日志输出的是日志级别大于error的日志信息
//所以这里最后输出的是error、critical日志
func testFuncException() {
    fmt.Println("testFuncException")
    testConfig := `
<seelog type="sync" minlevel="info">
    <exceptions>
        <exception funcpattern="*main.test*Except*" minlevel="error"/>
    </exceptions>
    <outputs>
        <console/>
    </outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("NOT Printed")
    log.Debug("NOT Printed")
    log.Info("NOT Printed")
    log.Warn("NOT Printed")
    log.Error("Printed")
    log.Critical("Printed")

    log.Current.Trace("NOT Printed")
    log.Current.Debug("NOT Printed")
    log.Current.Info("NOT Printed")
    log.Current.Warn("NOT Printed")
    log.Current.Error("Printed")
    log.Current.Critical("Printed")
}

//这里因为testFileException名不满足例外中的"*main.go"，所以返回的内容为大于info日志级别的日志内容，即info\warn\error\critical
func testFileException() {
    fmt.Println("testFileException")
    testConfig := `
<seelog type="sync" minlevel="info">
    <exceptions>
        <exception filepattern="*main.go" minlevel="error"/>
    </exceptions>
    <outputs>
        <console/>
    </outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("NOT Printed")
    log.Debug("NOT Printed")
    log.Info("NOT Printed")
    log.Warn("NOT Printed")
    log.Error("Printed")
    log.Critical("Printed")
}

返回：

userdeMBP:go-learning user$ go run test.go
testMinMax
 [Info] Printed
 [Warn] Printed
 [Error] Printed
testMin
 [Info] Printed
 [Warn] Printed
 [Error] Printed
 [Critical] Printed
testMax
 [Trace] Printed
 [Debug] Printed
 [Info] Printed
 [Warn] Printed
 [Error] Printed
testList
 [Trace] Printed
 [Info] Printed
 [Critical] Printed
testFuncException
 [Error] Printed
 [Critical] Printed
 [Error] Printed
 [Critical] Printed
testFileException
 [Info] NOT Printed
 [Warn] NOT Printed
 [Error] Printed
 [Critical] Printed

5.Dispatchers and receivers分配器和接收器

1）

接收器Receivers

我们对后端字节接收器使用“receiver”术语，如日志文件、网络通道等。

分配器Dispatchers

我们使用“dispatcher”术语表示向多个底层 接收者receivers/分配器dispatchers发送消息的中间元素。

举例说明：

进行dispatcher/receiver配置的主要目标是使用公共格式选项或允许的日志级别创建不同的组。例如，让我们创建一个示例配置:

<seelog>
    <outputs>
        <splitter formatid="common">
            <console/>
            <file path="file.log"/>
            <conn addr="192.168.0.2:8123"/>
        </splitter>
        <filter levels="critical">
            <file path="critical.log" formatid="critical"/>
            <smtp formatid="criticalemail" senderaddress="[e-mail]" sendername="Automatic notification service" hostname="mail.none.org" hostport="" username="nns" password="">
                <recipient address="[e-mail]"/>
                <recipient address="[e-mail]"/>
            </smtp>
        </filter>
    </outputs>
    <formats>
        <format id="common" format="[%LEV] %Msg"/>
        <format id="critical" format="%Time %Date %RelFile %Func %Msg"/>
        <format id="criticalemail" format="Critical error on our server!\n    %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
    </formats>
</seelog>

因此，在这里我们使用一个“splitter”元素来按格式(“common”)将三个接收器分组，其他两个接收器使用“filter”按允许的日志级别分组。注意，顶部的元素“output”本身就是一个拆分器splitter，因此我们可以简化配置:

<seelog>
    <outputs formatid="common">
        <console/>
        <file path="file.log"/>
        <conn addr="192.168.0.2:8123"/>
        <filter levels="critical">
            <file path="critical.log" formatid="critical"/>
            <smtp formatid="criticalemail" senderaddress="[e-mail]" sendername="Automatic notification service" hostname="mail.none.org" hostport="" username="nns" password="">
                <recipient address="[e-mail]"/>
                <recipient address="[e-mail]"/>
            </smtp>
        </filter>
    </outputs>
    <formats>
        <format id="common" format="[%LEV] %Msg"/>
        <format id="critical" format="%Time %Date %RelFile %Func %Msg"/>
        <format id="criticalemail" format="Critical error on our server!\n    %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
    </formats>
</seelog>

Formatting格式化

格式仅在写入字节接收器时应用。如果没有设置“formatid”，Dispatchers将继承格式标识符。如果设置了“formatid”，分配器和字节接收器将覆盖任何继承的格式。

让我们使用上面例子中的配置:

<seelog>
    <outputs formatid="common">
        <console/>
        <file path="file.log"/>
        <network address="192.168.0.2" port=""/>
        <filter levels="critical">
            <file path="critical.log" formatid="critical"/>
            <smtp formatid="criticalemail" senderaddress="[e-mail]" sendername="Automatic notification service" hostname="mail.none.org" hostport="" username="nns" password="">
                <recipient address="[e-mail]"/>
                <recipient address="[e-mail]"/>
            </smtp>
        </filter>
    </outputs>
    <formats>
        <format id="common" format="[%LEV] %Msg"/>
        <format id="critical" format="%Time %Date %RelFile %Func %Msg"/>
        <format id="criticalemail" format="Critical error on our server!\n    %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
    </formats>
</seelog>

它演示了继承/覆盖（inheritance/overriding）特性。最上面的splitter有formatid=“common”，因此它的所有子组件都继承它:console, file, network,和filter。filter中的file和smtp接收器不会继承它，因为它们用自己的格式文件覆盖它。如果smtp没有一个“formatid”属性集，那么它将从其父组件“filter”分配器中继承formatid=“common”。

示例

package main

import (
    "fmt"
    log "github.com/cihub/seelog"
    "time"
)

func main() {
    defer log.Flush()
    runExample(consoleWriter)
    runExample(fileWriter)
    runExample(rollingFileWriter)
    runExample(rollingFileWriterManyRolls)
    runExample(bufferedWriter)
    runExample(bufferedWriterWithFlushPeriod)
    runExample(bufferedWriterWithOverflow)
    runExample(splitDispatcher)
    runExample(filterDispatcher)
    //runExample(smtpWriter)
}

func runExample(exampleFunc func()) {
    exampleFunc()
    fmt.Println()
}

//在终端标准输出中输出"Console writer"
//并在终端输出5个trace日志信息
func consoleWriter() {
    testConfig := `
<seelog>
    <outputs>
        <console />
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Console writer")

    doLog()
}

//将5个trace日志信息写到文件./log/log.log中
func fileWriter() {

    testConfig := `
<seelog>
    <outputs>
        <file path="./log/log.log"/>
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("File writer")

    doLog()
}

//将日志信息写到回滚文件./log/roll.log中
//以大小size存储，文件最大为100个字节，文件个数最多为5
func rollingFileWriter() {
    testConfig := `
<seelog>
    <outputs>
        <rollingfile type="size" filename="./log/roll.log" maxsize="" maxrolls="" />
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Rolling file writer")

    doLog()
}

func rollingFileWriterManyRolls() {
    testConfig := `
<seelog>
    <outputs>
        <rollingfile type="size" filename="./log/manyrolls.log" maxsize="" maxrolls="" />
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Rolling file writer. Many rolls")

    doLogBig()
}

func bufferedWriter() {
    testConfig := `
<seelog>
    <outputs>
        <buffered size="">
            <file path="./log/bufFile.log"/>
        </buffered>
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Buffered file writer. NOTE: file modification time not changed until next test (buffered)")
    time.Sleep(3e9)
    for i := ; i < ; i++ {
        doLog()
        time.Sleep(5e9)
    }

    time.Sleep(2e9)
}

func bufferedWriterWithFlushPeriod() {
    testConfig := `
<seelog>
    <outputs>
        <buffered size="" flushperiod="">
            <file path="./log/bufFileFlush.log"/>
        </buffered>
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Buffered file writer with flush period. NOTE: file modification time changed after each 'doLog' because of small flush period.")
    time.Sleep(3e9)
    for i := ; i < ; i++ {
        doLog()
        time.Sleep(5e9)
    }

    time.Sleep(2e9)
}

//虽然溢出，但是日志信息仍全部存储
func bufferedWriterWithOverflow() {
    testConfig := `
<seelog>
    <outputs>
        <buffered size="">
            <file path="./log/bufOverflow.log"/>
        </buffered>
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Buffered file writer with overflow. NOTE: file modification time changes after each 'doLog' because of overflow")
    time.Sleep(3e9)
    for i := ; i < ; i++ {
        doLog()
        time.Sleep(5e9)
    }

    time.Sleep(1e9)
}

//日志信息在输入日志文件split.log同时也输出到标准输出中
func splitDispatcher() {
    testConfig := `
<seelog>
    <outputs>
        <file path="./log/split.log"/>
        <console />
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Split dispatcher")

    doLog()
}

//只有trace日志级别的信息存储到filter.log文件中，但是trace和debug的日志信息都会输出到标准输出中
func filterDispatcher() {
    testConfig := `
<seelog>
    <outputs>
        <filter levels="trace">
            <file path="./log/filter.log"/>
        </filter>
        <console />
    </outputs>
</seelog>
`
    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)
    fmt.Println("Filter dispatcher")

    for i:=; i < ; i++ {
        log.Trace("This message on console and in file")
        log.Debug("This message only on console")
    }
}

func smtpWriter() {
 testConfig := `
 <seelog>
  <outputs>
   <smtp senderaddress="[e-mail]" sendername="Automatic notification service" hostname="mail.none.org" hostport="" username="nns" password="">
    <recipient address="[e-mail]"/>
   </smtp>
  </outputs>
 </seelog>
 `
 logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
 log.ReplaceLogger(logger)
 fmt.Println("SMTP writer is now sending emails to the specified recipients")
 doLog()
}

func doLog() {
    for i:=; i < ; i++ {
        log.Tracef("%d", i)
    }
}

func doLogBig() {
    for i:=; i < ; i++ {
        log.Tracef("%d", i)
    }
}

返回：

userdeMBP:go-learning user$ go run test.go
Console writer

 [Trace]
 [Trace]
 [Trace]
 [Trace]
 [Trace]
File writer

Rolling file writer

Rolling file writer. Many rolls

Buffered file writer. NOTE: file modification time not changed until next test (buffered)

Buffered file writer with flush period. NOTE: file modification time changed after each 'doLog' because of small flush period.

Buffered file writer with overflow. NOTE: file modification time changes after each 'doLog' because of overflow

Split dispatcher

 [Trace]
 [Trace]
 [Trace]
 [Trace]
 [Trace]
Filter dispatcher
 [Trace] This message on console and in file
 [Debug] This message only on console
 [Trace] This message on console and in file
 [Debug] This message only on console
 [Trace] This message on console and in file
 [Debug] This message only on console
 [Trace] This message on console and in file

 [Debug] This message only on console
 [Trace] This message on console and in file
 [Debug] This message only on console

一个文件中最多有100个字节，因此这里一个文件中只写入了4行日志信息，其他的日志信息将另起一个文件存储，之前的文件将被重命名为roll.log.1，后来的日志内容仍会存在roll.log中，如果再超出，目前roll.log中的内容将存在名为roll.log.2的文件中，新内容仍存储在roll.log中

比如函数rollingFileWriter运行第一次的日志文件有两个，其内容为：

userdeMBP:go-learning user$ cat ./log/roll.log
 [Trace] 

userdeMBP:go-learning user$ cat ./log/roll.log.
 [Trace]
 [Trace]
 [Trace]
 [Trace] 

再运行一次函数rollingFileWriter，可见日志文件变成了三个，内容分别为：

userdeMBP:go-learning user$ cat ./log/roll.log.
 [Trace]
 [Trace]
 [Trace]
 [Trace] 

userdeMBP:go-learning user$ cat ./log/roll.log.
 [Trace]
 [Trace]
 [Trace]
 [Trace] 

userdeMBP:go-learning user$ cat ./log/roll.log
 [Trace]
 [Trace] 

运行函数rollingFileWriterManyRolls后，日志文件为：

可见该日志文件一直保持5个的数量，后面的日志将前面的日志覆盖

userdeMBP:go-learning user$ cat ./log/manyrolls.log.
 [Trace]
 [Trace]
 [Trace]
 [Trace]
userdeMBP:go-learning user$ cat ./log/manyrolls.log.
 [Trace]
 [Trace]
 [Trace]
 [Trace]
userdeMBP:go-learning user$ cat ./log/manyrolls.log
 [Trace]
 [Trace] 

2）分配器（dispatchers）列表：Reference

下面不同的dispatcher是用于指明发送消息的方式

1》Splitter dispatcher

功能：将接收到的消息发送到所有子节点。用于细分<outputs>日志格式，内部支持:file(文件), rollingfile(滚动文件，自动清除过期)

元素名：Splitter

允许属性：

• formatid—不覆盖它的所有子节点将继承的格式

举例说明：

<seelog>
    <outputs>
        <splitter formatid="format1">
            <file path="log.log"/>
            <file path="log2.log"/>
        </splitter>
        <splitter formatid="format2">
            <file path="log3.log"/>
            <file path="log4.log"/>
        </splitter>
    </outputs>
    <formats>
        ...
    </formats>
</seelog>

注:“output”元素也是一个Splitter，这只是顶部Splitter的一个特殊别名，因此，可以写成：

<seelog>
    <outputs>
        <file path="split.log"/>
        <console />
    </outputs>
</seelog>

上面的例子等价于：

<seelog>
    <splitter>
        <file path="split.log"/>
        <console />
    </splitter>
</seelog>

但后者在句法上并不正确。

2》Filter dispatcher

功能：仅当接收到的消息的日志级别在“allowed”列表中时，才向所有子节点发送接收到的消息。用于单独处理某个或某些级别日志

元素名：Filter

允许属性：

formatid—不覆盖它的所有子节点将继承的格式
levels—“allowed”列表中的逗号分隔的日志级别标识符(日志级别)列表

举例说明：

<seelog>
    <outputs>
        <filter levels="trace,debug">
        　　<file path="filter.log"/>
    　　 </filter>
        <console />
    </outputs>
</seelog>

3）接收器（receivers）列表：Reference

下面的不同种类的writer的目的其实就是将接收到的信息写入不同的地方

1》File writer

功能：将收到的消息写到一个文件中

元素名：file

允许属性：

• formatid—此接收器将使用的格式
• path——日志文件的路径

<seelog>
    <outputs>
        <file path="log.log"/>
    </outputs>
</seelog>

注意：

• 不要使用文件名中不允许的任何特殊符号。
• 不要在多进程环境中使用相同的文件，以避免日志不一致。

2》Console writer

功能：将收到的消息写到标准输出中

元素名：Console

允许属性：

• formatid—此接收器将使用的格式

<seelog>
    <outputs>
        <console/>
    </outputs>
</seelog>

3》Rolling file writer (or "Rotation file writer")

功能：将接收到的消息写入文件，直到日期更改或文件超过指定的限制。在此之后，将重命名当前日志文件并开始将日志写到新文件中。如果按大小滚动，可以设置重命名文件计数的限制(如果需要的话)，然后当文件计数超过指定的限制时，滚动写入器将删除旧的文件。

这样做的好处就是能够控制日志的大小，对于一个高流量的Web应用来说，日志的增长是十分可怕的。这样就能够保证日志文件不会因为不断变大而导致我们的磁盘空间不够引起问题

元素名：rollingfile

允许属性：

• formatid—此接收器将使用的格式
• filename-到日志文件的路径。在创建时，该路径被分为文件夹路径和实际文件名。后者将作为所有文件的公共部分，在滚动中起作用:

1. 在按“date”滚动的情况下，文件名将以这种方式形成:filename.DATE_PATTERN。例如(如果未设置全名标志，请参见下面):app.log, app.log.11.Aug.14, app.log.11.Aug.15
2. 在按'size'滚动的情况下，文件名将以这种方式形成:"filename.#"。例如app.log, app.log.1, app.log.2, app.log.3

• type-旋转类型:"date"或 "size"
• namemode-滚动文件的命名模式。可能的值:"postfix"（后缀）, "prefix"（前缀）。如果设置为“postfix”，滚动的文件看起来像'file.log.1', 'file.log.02.01.2006';如果设置为"prefix"，则看起来像是'1.file.log', '02.01.2006.file.log'。默认为"postfix"
• maxrolls -重命名文件的最大计数。当超过此限制时，将删除旧卷。值应该是>= 0。注意:在2.3版本之前，此属性不适用于“date”滚动写入器。
• archivetype—一个用于指定存储旧卷而不是删除旧卷的存档的类型的属性。可能的值:“none”、“zip”、“gzip”。如果设置为“none”，则不执行存档(只删除旧卷)。
• archiveexploded——一个用于指定日志是应该被分解还是分组到同一个归档文件中的属性。
• archivepath——当archivetype未设置为“none”时使用的属性。指定存储旧卷的存档的路径。

当允许'size'类型时的属性:

• maxsize——这是导致滚动的超出大小限制(以字节为单位)。

当允许'date'类型时的属性:

• datepattern—这是使用在“time.LocalTime().Format”去形成一个文件名的模式。当'time. localtime (). format (rollFileWriter.datePattern)'返回与当前文件名不同的内容时，将发生“date”(实际上，这意味着日期和时间)滚动。这意味着你可以使用带有日期标识符(如“02.01.2006”)的格式创建日滚动。或者你可以使用带有小时标识符(如“02.01.2006.15”)的格式创建小时滚动。
• fullname — 一个影响当前文件名的布尔属性。如果设置为“true”，则当前文件名将使用与卷名相同的命名约定。例如，日志文件列表将类似于app.log.11.Aug.13, app.log.11.Aug.14, app.log.11.Aug.15, ...，而不是app.log, app.log.11.Aug.14, app.log.11.Aug.15, ....。默认设置为false

⚠️

• 不要使用文件名中不允许的任何特殊符号。
• 不要在多进程环境中使用相同的文件，以避免日志不一致。

举例说明：

<seelog>
    <outputs>
        <rollingfile type="size" filename="logs/roll.log" maxsize="" maxrolls="" />
    </outputs>
</seelog>

<seelog>
    <outputs>
        <rollingfile type="date" filename="logs/roll.log" datepattern="02.01.2006" maxrolls="" />
    </outputs>
</seelog>

4》Buffered writer

功能：充当缓冲区包装其他写入器。缓冲写入器将数据存储在内存中，并在每次刷新周期或缓冲区满时刷新数据。将日志先存在内存中，定期写入文件，适合日志并发量较大或 IO 比较紧张的场合

元素名：buffered

允许的属性：

• formatid—此接收器将使用的格式
• size-缓冲区大小(以字节为单位)
• flushperiod——缓冲区刷新之间的间隔(单位为毫秒)

举例说明：

<seelog>
    <outputs>
        <buffered size="" flushperiod="">
            <file path="bufFile.log"/>
        </buffered>
    </outputs>
</seelog>

<seelog>
    <outputs>
        <buffered size="" flushperiod="" formatid="someFormat">
            <rollingfile type="date" filename="logs/roll.log" datepattern="02.01.2006" />
        </buffered>
    </outputs>
    <formats>
        ...
    </formats>
</seelog>

注意：该写入器使用特定格式累计写入的数据，然后将其刷新到内部写入器中。因此，内部写入器不能有自己的格式:仅为缓冲元素设置“formatid”，如上一个示例中所示。

5》SMTP writer

功能：在给定的post服务器上使用密码保护(但通常不安全)的电子邮件帐户向指定的收件人发送电子邮件。通过邮件smtp方式将日志文件发送出去(一般会发给相应的运维人员)

元素名：smtp

允许使用的属性：

• senderaddress-发件人的电子邮件地址
• sendername—发送方的名称
• hostname——post服务器的主机名(通常是mail.XXX.YYY)
• hostport - post服务器的TCP端口(通常为587)
• username——用于登录到post服务器的用户名
• password——post服务器的密码
• subject-电子邮件的主题

子元素名：recipient

允许使用的属性：

• address-收件人的电子邮件地址(接收来自通知者的消息)

子元素名：cacertdirpath

• path-到带有PEM证书文件的目录的路径。

举例说明：

<seelog>
  <outputs>
   <smtp senderaddress="[e-mail]" sendername="Automatic notification service" hostname="mail.none.org" hostport="" username="nns" password="">
    <recipient address="[e-mail]"/>
    <recipient address="[e-mail]"/>
   </smtp>
  </outputs>
 </seelog>

<seelog>
  <outputs>
   <filter levels="error,critical">
    <smtp senderaddress="[e-mail]" sendername="ANS" hostname="mail.none.org" hostport="" username="nns" password="" subject="test">
     <cacertdirpath path="cacdp1"/>
     <recipient address="[e-mail]"/>
     <header name="Priority" value="Urgent" />
     <header name="Importance" value="high" />
     <header name="Sensitivity" value="Company-Confidential" />
     <header name="Auto-Submitted" value="auto-generated" />
    </smtp>
   </filter>
  </outputs>
 </seelog>

注意：

查看上面的第一个示例，了解如何使用SMTP writer。请记住，电子邮件[e-mail]不能被认为是安全可靠的。由于配置中显式的发送密码，它可能会受到黑客攻击，我们强烈建议你不要为SMTP writer使用个人或公司的post帐户。最好的做法是专门设置一个独立的邮政帐户，特别是电子邮件通知服务。

第二个示例演示了使用这个编写器的最合理的方法——在(罕见的)特殊情况下使用应用程序的通知。从技术上讲，你可以设置其他过滤级别，但也要做好被诊断邮件淹没的准备。

可以设置当发生了错误的时候我们就能够将错误信息发送给运维，这样就就能够在遇到问题时及时处理

6》Conn writer

功能：将接收到的消息写入网络连接。

元素名：conn

允许使用的属性：

• formatid— 此接收器将使用的格式
• net— 使用的网络(“tcp”, “udp”,“tcp4”、“udp4”……)
• addr -网络地址(":1000"，"127.0.0.1:8888"，…)
• reconnectonmsg -如果为true，连接将在每次写入时打开，否则在第一次写入时打开。默认为false。
• usetls -如果为true，将使用TLS。
• insecureskipverify — 设置tls.Config的InsecureSkipVerify标志。如果设置了useTLS就使用它

举例说明：

<seelog type="sync">
    <outputs>
        <conn net="tcp" addr=":8888" />
    </outputs>
</seelog>

<outputs>
  <conn formatid="syslog" net="tcp4" addr="server.address:5514" tls="true" insecureskipverify="true" />
</outputs>
<formats>
  <format id="syslog" format="%CustomSyslogHeader(20) %Msg%n"/>
</formats>

%CustomSyslogHeader的示例代码可以查看下面的 4）Custom formatters自定义格式器 - 2》

6.Formatting格式化

1）

Seelog提供了更改发送到字节接收器的消息格式的功能。格式设置在“formats”配置部分，如下:

<formats>
    <format id="common" format="[%LEV] %Msg"/>
    <format id="critical" format="%Time %Date %RelFile %Func %Msg"/>
    <format id="criticalemail" format="Critical error on our server!\n    %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
</formats>

每个“format”节点都有一个“id”和“format”属性。Id是用于将格式链接到dispatchers/receiver的格式的唯一标识符。“format”属性用于用特殊的格式化对象指定格式字符串，以“%”符号开头。当将消息写入字节接收器时，这些特殊符号将被上下文值或特殊字符串替换。

要查看格式是如何链接到dispatchers/receiver的，查看上面 Dispatchers and receivers分配器和接收器 的“Formatting”部分

2）formatters列表

1》Message context消息上下文

• %Level - 日志级别 (Trace, Debug, Info, Warn, Error, Critical)
• %Lev - 短日志级别 (Trc, Dbg, Inf, Wrn, Err, Crt)
• %LEVEL - 大写的日志级别 (TRACE, DEBUG, INFO, WARN, ERROR, CRITICAL)
• %LEV - 缩写版大写日志级别 (TRC, DBG, INF, WRN, ERR, CRT)
• %l - 超简写版日志级别(t, d, i, w, e, c)
• %Msg - 消息文本 (string)
• %FullPath - 完整的调用者文件路径
• %File - 只调用文件名
• %RelFile - 相对于应用程序运行目录的调用者路径
• %Func - 调用函数名
• %FuncShort - 调用函数名的最后一个点后面的部分
• %Line - 日志记录器被调用时的行号

2》日期和时间

• %Ns - time.Now().UnixNano()
• %Date - 指明日期格式为‘2006-01-02’的快捷方式
• %Time - 指明时间格式为‘15:04:05’的快捷方式
• %Date(...) - 日期的格式，指定在括号中。使用标准time.Format，因此请检查http://golang.org/src/pkg/time/format.go中的标识符列表。可以这样使用:“%Date(2006-01-02)”(或任何其他格式)
• %UTCNs - time.Now().UTC().UnixNano()
• %UTCDate - 指明日期格式为‘2006-01-02’ (UTC)的快捷方式
• %UTCTime - 指明时间格式为‘15:04:05’ (UTC)的快捷方式
• %UTCDate(...) - UTC日期的格式，指定在括号中。使用标准时间。格式，因此请检查http://golang.org/src/pkg/time/format.go中的标识符列表。可以这样使用:“%UTCDate(2006-01-02)”(或任何其他格式)

3》特殊符号

• %EscN - terminal ANSI CSI n [;k] m escape. 检查彩色输出的详细信息
• %n - 换行符
• %t - 制表符

3）Predefined formats预定义格式

Seelog配置解析器识别一组特殊的格式标识符，称为预定义格式。引入这些标识符是为了避免每次在配置文件中显式创建“xml”或“json”等公共格式。

1》使用

使用任何输出节点的“formatid”属性中的预定义格式标识符之一。

格式标识符的全名由前缀std:和下面列出的标识符之一组成。以下是完整的id-format对的列表:

• xml-debug: <time>%Ns</time><lev>%Lev</lev><msg>%Msg</msg><path>%RelFile</path><func>%Func</func>
• xml-debug-short: <t>%Ns</t><l>%l</l><m>%Msg</m><p>%RelFile</p><f>%Func</f>
• xml: <time>%Ns</time><lev>%Lev</lev><msg>%Msg</msg>
• xml-short: <t>%Ns</t><l>%l</l><m>%Msg</m>
• json-debug: {"time":%Ns,"lev":"%Lev","msg":"%Msg","path":"%RelFile","func":"%Func"}
• json-debug-short: {"t":%Ns,"l":"%Lev","m":"%Msg","p":"%RelFile","f":"%Func"}
• json: {"time":%Ns,"lev":"%Lev","msg":"%Msg"}
• json-short: {"t":%Ns,"l":"%Lev","m":"%Msg"}
• debug: [%LEVEL] %RelFile:%Func %Date %Time %Msg%n
• debug-short: [%LEVEL] %Date %Time %Msg%n
• fast: %Ns %l %Msg%n

注意：

使用你自己的格式覆盖预定义的格式并使用以std:开头的标识符创建你自己的格式是完全合法的，但是不建议使用这两种做法。

举例说明：

<seelog>
    <outputs formatid="std:json">
        <console/>
    </outputs>
</seelog>

seelog.Info("Hello world!")输出为：

{"time":,"lev":"Inf","msg":"Hello world!"}

将以json的格式输出信息到标准输出中

 

4）Custom formatters自定义格式器

如果你觉得上面2）formatters列表 中的标准格式化集还不够，你可以指定自己的自定义格式化程序。

要做到这一点，你必须使用seelog。使用RegisterCustomFormatter函数去为你要使用的新格式别名注册工厂。在此之后(如果返回的错误为nil)，你可以在随后创建的任何日志记录器中使用指定的格式别名。

自定义格式化器可以参数化。参数字符串(括号内)如果存在，则传递给你注册的工厂func。

让我们看几个例子。

1》Alternative log level names可选日志级别名称

注册你的新格式器：

var myLevelToString = map[log.LogLevel]string{ //这是我自定义的格式，重命名对应的日志级别
    log.TraceLvl:    "MyTrace",
    log.DebugLvl:    "MyDebug",
    log.InfoLvl:     "MyInfo",
    log.WarnLvl:     "MyWarn",
    log.ErrorLvl:    "MyError",
    log.CriticalLvl: "MyCritical",
    log.Off:         "MyOff",
}

func createMyLevelFormatter(params string) log.FormatterFunc {
    return func(message string, level log.LogLevel, context log.LogContextInterface) interface{} {
        levelStr, ok := myLevelToString[level]
        if !ok {
            return "Broken level!"
        }
        return levelStr
    }
}

func init() {
    err := log.RegisterCustomFormatter("MyLevel", createMyLevelFormatter) //注册
    if err != nil {
         ...
    }
}

现在你可以在你的配置中使用注册的“MyLevel”:

<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%MyLevel %Msg%n"/>
    </formats>
</seelog>

使用这个配置后一个日志记录器将创建：

log.Trace("Test message!")

输出为：

MyTrace Test message!

2》用于TLS连接并写入syslog的格式器

注册你的格式器：

var hostName string
var appName = "test"
var pid int

var levelToSyslogSeverity = map[log.LogLevel]int{
    // Mapping to RFC 5424 where possible
    log.TraceLvl:    ,
    log.DebugLvl:    ,
    log.InfoLvl:     ,
    log.WarnLvl:     ,
    log.ErrorLvl:    ,
    log.CriticalLvl: ,
    log.Off:         ,
}

func createSyslogHeaderFormatter(params string) log.FormatterFunc {
    facility :=
    i, err := strconv.Atoi(params)
    if err == nil && i >=  && i <=  {
        facility = i
    }

    return func(message string, level log.LogLevel, context log.LogContextInterface) interface{} {
        return fmt.Sprintf("<%d>1 %s %s %s %d - -", facility*+levelToSyslogSeverity[level],
            time.Now().Format("2006-01-02T15:04:05Z07:00"),
            hostName, appName, pid)
    }
}

func init() {
    hostName, _ = os.Hostname()
    pid = os.Getpid()

    err := log.RegisterCustomFormatter("CustomSyslogHeader", createSyslogHeaderFormatter)
    if err != nil {
        ...
    }
}

现在你可以在你的配置中使用注册的“CustomSyslogHeader”:

<outputs>
  <conn formatid="syslog" net="tcp4" addr="server.address:5514" tls="true" insecureskipverify="true" />
</outputs>
<formats>
  <format id="syslog" format="%CustomSyslogHeader(20) %Msg%n"/>
</formats>

使用这个配置后一个日志记录器将被创建：

log.Info("Test message!")

输出为：

<> --14T21::+: imp-pcl test  - - Test message!

示例：

package main

import (
    log "github.com/cihub/seelog"
    "fmt"
)

func main() {
    defer log.Flush()
    defaultFormat()
    stdFormat()
    dateTimeFormat()
    dateTimeCustomFormat()
    logLevelTypesFormat()
    fileTypesFormat()
    funcFormat()
    xmlFormat()
}

//测试的是默认的格式
func defaultFormat() {
    fmt.Println("Default format")

    testConfig := `
<seelog type="sync" />`

    logger, err := log.LoggerFromConfigAsBytes([]byte(testConfig))
    if err != nil {
        fmt.Println(err)
    }
    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

//标准格式
func stdFormat() {
    fmt.Println("Standard fast format")

    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%Ns [%Level] %Msg%n"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

//日期和时间的格式默认
func dateTimeFormat() {
    fmt.Println("Date time format")

    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%Date/%Time [%LEV] %Msg%n"/>
    </formats>
</seelog>`

    logger, err := log.LoggerFromConfigAsBytes([]byte(testConfig))

    if err != nil {
        fmt.Println(err)
    }

    loggerErr := log.ReplaceLogger(logger)

    if loggerErr != nil {
        fmt.Println(loggerErr)
    }

    log.Trace("Test message!")
}

//自定义的日期和时间格式
func dateTimeCustomFormat() {
    fmt.Println("Date time custom format")

    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%Date(2006 Jan 02/3:04:05.000000000 PM MST) [%Level] %Msg%n"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

//日志级别类型格式
func logLevelTypesFormat() {
    fmt.Println("Log level types format")

    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%Level %Lev %LEVEL %LEV %l %Msg%n"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

//文件类型格式
func fileTypesFormat() {
    fmt.Println("File types format")

    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%File %FullPath %RelFile %Msg%n"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

//函数格式
func funcFormat() {
    fmt.Println("Func format")

    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="%Func %Msg%n"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

//xml格式
func xmlFormat() {
    fmt.Println("Xml format")

    //等价于<time>%Ns</time><lev>%Lev</lev><msg>%Msg</msg><path>%RelFile</path><func>%Func</func>
    testConfig := `
<seelog type="sync">
    <outputs formatid="main">
        <console/>
    </outputs>
    <formats>
        <format id="main" format="` +
        `&lt;log&gt;` +
             `&lt;time&gt;%Ns&lt;/time&gt;` +
             `&lt;lev&gt;%l&lt;/lev&gt;` +
             `&lt;msg&gt;%Msg&lt;/msg&gt;` +
         `&lt;/log&gt;"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))

    log.ReplaceLogger(logger)

    log.Trace("Test message!")
}

返回：

userdeMBP:go-learning user$ go run test.go
Default format
 [Trace] Test message!
Standard fast format
 [Trace] Test message!
Date time format
--/:: [TRC] Test message!
Date time custom format
 Mar /::01.896487000 PM CST [Trace] Test message!
Log level types format
Trace Trc TRACE TRC t Test message!
File types format
test.go /Users/user/go-learning/test.go test.go Test message!
Func format
main.funcFormat Test message!
Xml format
<log><time></time><lev>t</lev><msg>Test message!</msg></log>

7.Colorizing output着色输出

有时你可能想要对终端输出进行着色。这通常使用CSI n [;k] m序列来完成。

Seelog格式使用XML设置，因此无法在格式标识符中使用这些序列。但是有一种特殊格式的动词叫做“EscM”，它以“n[;k]”部分作为参数。你可以使用它来为终端输出执行图形化选项定制。

举例说明：

<seelog>
    <outputs>
        <console formatid="colored"/>
    </outputs>
    <formats>
        <format id="colored"  format="%EscM(46)%Level%EscM(49) %Msg%n%EscM(0)"/>
    </formats>
</seelog>

使用上面的配置，然后记录任何消息，日志级别将有青色背景。46设置背景，49将其重置。

建议

在消息末尾使用%EscM(0)(以及%n)重置所有图形更改

8.Migration from standard log package从标准日志包迁移

对于那些希望在已经通过标准pkg使用日志功能的应用程序中开始使用seelog的人来说，从日志包迁移到seelog是一项常见的任务。

1）不兼容性

Seelog概念与标准日志概念不同，因此它们不兼容。

例1 : log.Printf。在seelog中没有类似的函数，因为Printf不携带任何日志级别的信息，所以如果要迁移，不清楚应该怎么替换log.Printf。可能是seelog.Infof或seelog.Debugf 或其他。

例2 : log.Panicf。它根据格式和panic创建消息，使用格式化的消息作为panic文本。在seelog中，对任何日志函数的一次调用都可能产生具有不同格式(取决于配置)的多个消息，因此不清楚应该使用什么作为panic文本。

例3 : log.SetPrefix。Seelog没有类似的函数，因为对任何日志函数(例如Debug)的一次调用都可能产生具有不同格式的多个消息，因此使用一个这样的全局函数是没有意义的。此外，seelog的核心原则之一是避免通过代码进行配置。所有配置都是通过配置文件进行的。这样的函数会打破seelog的概念。

2）结论

目前(Go1.X)， seelog不兼容标准日志包，不能有任何“标准日志pkg兼容性”的功能。

3）迁移注意点

尽管实际上你不能用seelog替换日志，并且具有相同的行为(如前所述，它们只是不兼容)，但是你可能希望自动化从日志到seelog的迁移。我们建议为你的项目创建一个替代脚本

迁移脚本示例：

下面是一个Python脚本，它在多个文件中对多个日志包函数执行一些替换。它可以作为存根来满足你自己的替换需求。

import os, sys,shutil,re

changeDir= './test'
openFlags = 'rb'
writeFlags = 'r+b'
encoding = 'utf-8'
backupPostfix = '.backup'

goFilesRx = r'.+\.go$'

patterns = [

(re.compile(ur'''(?P<before>import[\s\S]*?)"log"''', re.U | re.M),
            ur'''\g<before>log "github.com/cihub/seelog"'''), # change import

(re.compile(ur'''log.Print(?P<after>.*?)''', re.U),
            ur'''log.Info\g<after>'''), # Print -> Info

(re.compile(ur'''log.Println(?P<after>.*?)''', re.U),
            ur'''log.Info\g<after>'''), # Println -> Info

(re.compile(ur'''log.Printf(?P<after>.*?)''', re.U),
            ur'''log.Infof\g<after>'''), # Printf -> Infof

(re.compile(ur'''(?P<ws>[\t ]*)log.Panic\((?P<values>.*?)\)''', re.U),
            ur'''\g<ws>log.Info(\g<values>)\n\g<ws>panic(fmt.Sprint(\g<values>))'''), # Panic -> Info + panic(...)

(re.compile(ur'''(?P<ws>[\t ]*)log.Panicf\((?P<values>.*?)\)''', re.U),
            ur'''\g<ws>log.Infof(\g<values>)\n\g<ws>panic(fmt.Sprint(\g<values>))'''), # Panicf -> Info + panic(...)

# ... and so on

]

def rewriteFile(fl, text):
   fl.read() # To preserve file creation date
   fl.seek()
   fl.write(text.encode(encoding))
   fl.truncate()

def replacePatterns(filePath, backup):
   # Open file and get its contents
   input = open(filePath, openFlags)
   fileText = unicode(input.read(), encoding)
   input.close()

   found = False
   # Make replacements for all patterns
   for pc in patterns:
      origRx = pc[]
      replRx = pc[]
      replacedText = re.sub(origRx, replRx, fileText)
      if fileText != replacedText:
         found = True
      fileText = replacedText

   # If any replacements were made, write the changed file
   if found:
      if backup:
         bckName = filePath + backupPostfix
         shutil.copy2(filePath, bckName)

      outF = open(filePath,writeFlags)
      rewriteFile(outF, fileText)
      outF.close()

def replaceFunc(a, dir, files):
   for f in files:
      fPath = dir + '/' + f
      if re.search(goFilesRx, f, re.U) and os.path.isfile(fPath):
         replacePatterns(fPath, True)

os.path.walk(changeDir, replaceFunc, )

9.Example config

这个配置没有任何实际价值，它只是在一个地方演示了大多数功能。有关详细信息，请查看wiki，它包含每个seelog特性的描述。要快速参考，请查看参考reference部分。

<seelog type="asynctimer" asyncinterval="" minlevel="debug" maxlevel="error">
    <exceptions>
        <exception funcpattern="*main.test*Something*" minlevel="info"/>
        <exception filepattern="*main.go" minlevel="error"/>
    </exceptions>
    <outputs formatid="main"> //指明其将使用在<formats>中的<format id="main" 处指明的格式来输出信息，如果里面的子元素中有定义自己的formatid，将会将其覆盖
        <console/> //指明将outputs中的日志内容在输入到文件、内存、SMTP等的同时还输出到标准输出，即终端中

        <splitter formatid="format1"> //指明将输出以<format id="format1"格式写到log.log和log2.log文件中
            <file path="log.log"/>
            <file path="log2.log"/>
        </splitter>
        <splitter formatid="format2"> //splitter用于细分<outputs>日志格式
            <file path="log3.log"/>
            <file path="log4.log"/>
        </splitter>

        <rollingfile formatid="someformat" type="size" filename="./log/roll.log" maxsize="" maxrolls="" /> //指明将输出以<format id="someformat"格式写到./log/roll.log 回滚文件中

        <buffered formatid="testlevels" size="" flushperiod=""> //指明将输出以<format id="testlevels"格式写到缓冲区(即内存)中，然后再存储到./log/bufFileFlush.log文件中
            <file path="./log/bufFileFlush.log"/>
        </buffered>

        <filter levels="error"> //只显示error日志级别
            <file path="./log/error.log"/> //写到该文件中
            <smtp senderaddress="[e-mail]"  //并将日志内容发送给下面<recipient指定的接收者
                  sendername="Automatic notification service"
                  hostname="mail.none.org"
                  hostport=""
                  username="nns"
                  password="">
                <recipient address="[e-mail]"/>
                <recipient address="[e-mail]"/>
            </smtp>
            <conn net="tcp4" addr="server.address:5514" tls="true" insecureskipverify="true" /> //同时也将这个日志内容通过网络传输到地址server.address:5514上
        </filter>

    </outputs>
    <formats> //这里就是指定上面对应的日志内容输出应该分别使用什么样的格式
        <format id="main" format="%Date(2006 Jan 02/3:04:05.000000000 PM MST) [%Level] %Msg%n"/>
        <format id="someformat" format="%Ns [%Level] %Msg%n"/>
        <format id="testlevels" format="%Level %Lev %LEVEL %LEV %l %Msg%n"/>
        <format id="usetags" format="&lt;msg&gt;%Msg&lt;/time&gt;"/>
        <format id="format1" format="%Date/%Time [%LEV] %Msg%n"/>
        <format id="format2" format="%File %FullPath %RelFile %Msg%n"/>
    </formats>
</seelog>

10.Logger types reference类型

日志记录器类型设置在顶部的“seelog”元素中。属性名是“type”。

1）Synchronous同步

功能：在调用log func的相同goroutine中处理日志消息

类型属性值：Sync

额外属性：None

举例说明：

<seelog type="sync">
    ...
</seelog>

2）Asynchronous loop异步循环

功能：在单独的goroutine中处理日志消息。从“for”循环中的消息队列获取消息。

类型属性值：asyncloop（这是默认类型，所以你可以忽略“type”属性）

额外属性：none

举例说明，下面的两种写法是等价的：

<seelog type="asyncloop">
    ...
</seelog>

等价于：

<seelog>
    ...
</seelog>

3）Asynchronous timer异步计时器

功能：在单独的goroutine中处理日志消息。获取具有指定时间间隔的消息队列中的消息。

类型属性值：asynctimer

额外属性：

• asyncinterval——计时器时间间隔(以纳秒为单位)

举例说明：

<seelog type="asynctimer" asyncinterval="">
    ...
</seelog>

示例：

package main

import (
    "fmt"
    log "github.com/cihub/seelog"
    "strings"
    "time"
)

var longMessage = strings.Repeat("A", *)

func main() {
    defer log.Flush()
    syncLogger()
    fmt.Println()
    asyncLoopLogger()
    fmt.Println()
    asyncTimerLogger()
}

func syncLogger() {
    fmt.Println("Sync test")

    testConfig := `
<seelog type="sync">
    <outputs>
        <filter levels="trace">
            <file path="log.log"/>
        </filter>
        <filter levels="debug">
            <console />
        </filter>
    </outputs>
</seelog>
`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.UseLogger(logger)

    doTest()
}

func asyncLoopLogger() {
    fmt.Println("Async loop test")

    testConfig := `
<seelog>
    <outputs>
        <filter levels="trace">
            <file path="log.log"/>
        </filter>
        <filter levels="debug">
            <console />
        </filter>
    </outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.UseLogger(logger)

    doTest()

    time.Sleep(1e9)
}

func asyncTimerLogger() {
    fmt.Println("Async timer test")

    testConfig := `
<seelog type="asynctimer" asyncinterval="">
    <outputs>
        <filter levels="trace">
            <file path="log.log"/>
        </filter>
        <filter levels="debug">
            <console />
        </filter>
    </outputs>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))
    log.UseLogger(logger)

    doTest()

    time.Sleep(1e9)
}

func doTest() {
    start := time.Now()
    for i := ; i < ; i +=  {
        fmt.Printf("%d\n", i)
        log.Trace(longMessage)
        log.Debugf("%d", i+)
    }
    end := time.Now()
    dur := end.Sub(start)
    fmt.Printf("Test took %d ns\n", dur)
}

返回

userdeMBP:go-learning user$ go run test.go
Sync test //同步进行

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug]
Test took  ns

Async loop test //循环同时获取日志消息

 [Debug]
 [Debug] 

 [Debug]
 [Debug]
 [Debug] 

 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug] 

 [Debug]
 [Debug] 

 [Debug]
 [Debug] 

 [Debug] 

 [Debug] 

 [Debug] 

 [Debug]
 [Debug] 

 [Debug] 

 [Debug]
 [Debug] 

 [Debug]
 [Debug]
Test took  ns
 [Debug] 

Async timer test

Test took  ns //async Timer设置是5000000ns后才开始读取日志消息
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug]
 [Debug] 

4）Asynchronous adaptive异步适应性

功能：类似于异步计时器日志记录器，但其间隔取决于队列中剩下的消息数量。创建这种类型的日志记录器是为了避免日志消息队列溢出:队列中的消息越多，获取它们的速度就越快。在seelogg -example:adaptive_main.go中进行了演示：

package main

import (
    "time"
    log "github.com/cihub/seelog"
)

func main() {
    defer log.Flush()
    loadAdaptiveConfig()
    testMsgIntensity()
    testMsgIntensity()
    testMsgIntensity()
}

func testMsgIntensity(intensity int) {
    log.Default.Infof("Intensity test: %d", intensity)

    for j := ; j < ; j++ {
        for i := ; i < intensity; i++ {
            log.Tracef("trace %d", i)
            <-time.After(time.Second / time.Duration(intensity)) //time.Second / time.Duration(5)表示1秒除以5的时间进行一次循环
        }
    }

    log.Default.Info("Messages sent")

    <-time.After(time.Second * time.Duration(intensity))
}

func loadAdaptiveConfig() {
    testConfig := `<seelog type="adaptive" mininterval="" maxinterval="" critmsgcount="">
    <outputs formatid="msg">
        <console/>
    </outputs>
    <formats>
        <format id="msg" format="%Time: %Msg%n"/>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig))

    log.ReplaceLogger(logger)
}

返回：

userdeMBP:go-learning user$ go run test.go
 [Info] Intensity test:
::: trace
::: trace
::: trace
::: trace
 [Info] Messages sent
 [Info] Intensity test:
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
 [Info] Messages sent
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
 [Info] Intensity test:
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
 [Info] Messages sent
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace
::: trace 

如果我们使用下面的概念：

• I - 获取下一项之前的间隔
• m - 最小间隔
• M - 极大区间
• c - 当前消息计数
• C - 关键信息计数

计算间隔的公式为：

I = m + (C - Min(c, C)) / C * (M - m)

类型属性值：adaptive

额外属性：

• mininterval-最小间隔(以纳秒为单位)
• maxinterval -最大间隔(以纳秒为单位)
• critmsgcount -关键消息计数

举例说明：

<seelog type="adaptive" mininterval="" maxinterval="" critmsgcount="">
    <outputs formatid="msg">
        <console/>
    </outputs>
    <formats>
        <format id="msg" format="%Time: %Msg%n"/>
    </formats>
</seelog>

11.简单举例：

1）仅将日志输出到终端

配置文件seelog.xml为,参考https://blog.csdn.net/luckytanggu/article/details/80345134：

<seelog type="asynctimer" asyncinterval="" minlevel="debug" maxlevel="error">
    <outputs formatid="main">
        <!-- 仅实现将日志内容输出到终端 -->
        <console/>
    </outputs>
    <formats>
        <!-- 设置格式，输出UTC日期 UTC时间 - 缩写版大写日志级别 - 相对于应用程序运行目录的调用者路径 - 日志记录器被调用时的行号 - 消息文本（最后换行） -->
        <format id="main" format="%UTCDate %UTCTime - [%LEV] - %RelFile - l%Line - %Msg%n"/>
    </formats>
</seelog>

然后应用为：

package main

import (
    log "github.com/cihub/seelog"
    "fmt"
)

func main() {
    logger, err := log.LoggerFromConfigAsFile("seelog.xml")

    if err != nil {
        fmt.Println("parse seelog.xml error")
    }

    log.ReplaceLogger(logger)

    defer log.Flush()
    log.Info("Hello from Seelog!")

}

输出为：

userdeMBP:go-learning user$ go run test.go
-- :: - [INF] - test.go - l20 - Hello from Seelog!

2）将日志输出到终端和文件中

<seelog type="asynctimer" asyncinterval="" minlevel="debug" maxlevel="error">
    <outputs formatid="main">
        <!-- 仅实现将日志内容输出到终端 -->
        <console/>
        <!-- 该文件将使用"format1"格式来覆盖"main"格式，并将文件信息写到log.log文件中-->
        <splitter formatid="format1">
            <file path="log.log"/>
        </splitter>
    </outputs>
    <formats>
        <!-- 设置格式，输出UTC日期 UTC时间 - 缩写版大写日志级别 - 相对于应用程序运行目录的调用者路径 - 日志记录器被调用时的行号 - 消息文本（最后换行） -->
        <format id="main" format="%UTCDate %UTCTime - [%LEV] - %RelFile - l%Line - %Msg%n"/>
        <!-- 格式为以2006 Jan /::05.000000000 PM MST格式输出日期 正常的日志级别 消息文本（最后换行）-->
        <format id="format1" format="%Date(2006 Jan 02/3:04:05.000000000 PM MST) [%Level] %Msg%n"/>
    </formats>
</seelog>

然后返回：

userdeMBP:go-learning user$ go run test.go
-- :: - [INF] - test.go - l20 - Hello from Seelog!

日志文件中的输出为：

userdeMBP:go-learning user$ cat log.log
 Mar /::35.215823000 PM CST [Info] Hello from Seelog!