go第三方日誌系統-seelog-使用文檔

時間 2019-11-09

標籤第三方日誌系統 seelog 使用文檔简体版

原文原文鏈接

參考：https://godoc.org/github.com/cihub/seeloghtml

導入方式：git

import "github.com/cihub/seelog"

包seelog經過靈活的調度、過濾和格式化實現日誌功能。github

1.建立安全

使用下面的構造函數來建立一個日誌記錄器：網絡

func LoggerFromConfigAsBytes
func LoggerFromConfigAsFile
func LoggerFromConfigAsString
func LoggerFromWriterWithMinLevel
func LoggerFromWriterWithMinLevelAndFormat
func LoggerFromCustomReceiver(check https://github.com/cihub/seelog/wiki/Custom-receivers)

舉例：app

配置文件seelog.xml爲,參考https://blog.csdn.net/luckytanggu/article/details/80345134：異步

<seelog type="asynctimer" asyncinterval="1000000" 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>

而後應用爲：async

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!") }

輸出爲：tcp

userdeMBP:go-learning user$ go run test.go 
2019-03-04 09:19:11 - [INF] - test.go - l20 - Hello from Seelog!

「defer」行語句很重要，由於若是使用異步日誌行爲，在關閉應用程序時，若是沒有這行，可能會丟失一些消息，由於它們是在另外一個非阻塞goroutine中處理的。爲了不這種狀況，在關閉以前顯式地延遲刷新全部消息。ide

2.使用

能夠經過調用主日誌函數其中之一的函數來直接使用上面的任一個LoggerFrom*函數來建立日誌記錄器

import log "github.com/cihub/seelog"

func main() {
    logger, err := log.LoggerFromConfigAsFile("seelog.xml")
    if err != nil {
        panic(err)
    }
    defer logger.Flush()
    logger.Trace("test")
    logger.Debugf("var = %s", "abc")
}

若是你正在使用內部日誌記錄編寫本身的包，或者你有幾個具備不一樣選項的日誌記錄程序，那麼使用日誌記錄程序做爲變量是很是方便的。可是對於大多數獨立的應用程序來講，使用包級函數和變量會更方便。有一個包級別的變量'Current'就是爲它而建的（即上面的logger等價於log.Current）。你也可使用「ReplaceLogger」將其替換爲另外一個日誌記錄器，而後使用包級別函數:

import log "github.com/cihub/seelog"

func main() {
    logger, err := log.LoggerFromConfigAsFile("seelog.xml")
    if err != nil {
        panic(err)
    }
    log.ReplaceLogger(logger)
    defer log.Flush()
    log.Trace("test")
    log.Debugf("var = %s", "abc")
}

兩面的最後兩行等價於：

log.Current.Trace("test")
log.Current.Debugf("var = %s", "abc")

在本例中，'Current'日誌記錄器被替換爲使用'ReplaceLogger'調用，併成爲由config建立的'logger'變量。經過這種方式，你能夠使用包級別函數，而不是傳遞logger變量。

3.配置:

1）可見go第三方日誌系統-seelog-Basic sections

2）使用代碼進行配置：

雖然不建議使用代碼進行配置，但有時須要使用代碼，可使用seelog進行配置。基本上，開始時你須要作的是建立約束、例外和分配器樹(與配置相同)。這個包中的大多數New*類函數都用於提供此類功能。

下面是代碼中的配置示例，它演示了一個異步循環日誌記錄器，該記錄器使用指定的格式來使用控制檯接收器將日誌記錄到一個簡單的分割分配器上，並使用最高級別的min-max約束和一個對「main.go」文件的例外進行篩選。因此，這基本上是對大多數功能配置的演示:

package main

import log "github.com/cihub/seelog"

func main() {
    defer log.Flush()
    log.Info("Hello from Seelog!") //這個使用的是默認的日誌記錄器

    consoleWriter, _ := log.NewConsoleWriter() //建立一個新的控制檯寫入器
    formatter, _ := log.NewFormatter("%Level %Msg %File%n") //等價於配置中的<format>聲明格式
    root, _ := log.NewSplitDispatcher(formatter, []interface{}{consoleWriter}) //即等價於配置中的<output>,formatter是該分配器指定的格式，接收到的日誌信息指定接收器爲標準輸出
    constraints, _ := log.NewMinMaxConstraints(log.TraceLvl, log.CriticalLvl) //使用指定的最小和最大級別建立一個新的minMaxConstraints對象結構，即specificConstraints，指明一個範圍內的級別
    specificConstraints, _ := log.NewListConstraints([]log.LogLevel{log.InfoLvl, log.ErrorLvl})//一個個指明可用的級別，這裏即只能使用info和error這兩個級別
    ex, _ := log.NewLogLevelException("*", "*main.go", specificConstraints)
    exceptions := []*log.LogLevelException{ex} //生成一個*log.LogLevelException對象列表

    logger := log.NewAsyncLoopLogger(log.NewLoggerConfig(constraints, exceptions, root))//使用了這個函數就可以生成一個完整的seelog配置了
    log.ReplaceLogger(logger)

    //下面的內容使用的就是咱們上面自定義的日誌生成器了
    log.Trace("This should not be seen")
    log.Debug("This should not be seen")
    log.Info("Test")
    log.Error("Test2")
}

userdeMBP:go-learning user$ go run test.go 
1551754090234813000 [Info] Hello from Seelog!
Trace This should not be seen test.go
Debug This should not be seen test.go
Info Test test.go
Error Test2 test.go

相關使用的函數：

func NewConsoleWriter

func NewConsoleWriter() (writer *consoleWriter, err error)

建立一個新的控制檯寫入器。若是沒法建立控制檯寫入器，則返回錯誤。

func NewFormatter

func NewFormatter(formatString string) (*formatter, error)

NewFormatter使用格式字符串建立新的格式化程序，即等價於配置中的<format>聲明格式

func NewSplitDispatcher

func NewSplitDispatcher(formatter *formatter, receivers []interface{}) (*splitDispatcher, error)

聲明一個Dispatcher分配器，即等價於配置中的<Splitter>。第一個參數即指定該分配器消息輸出使用的格式，第二個參數指定的是日誌的接收器，便是輸出到標準輸出，仍是文件等

func NewMinMaxConstraints

func NewMinMaxConstraints(min LogLevel, max LogLevel) (*minMaxConstraints, error)

NewMinMaxConstraints使用指定的最小和最大級別建立一個新的minMaxConstraints結構。指明配置中的某個分配器中可以輸出的日誌級別的最大最小限制，這是指定一個範圍

func NewListConstraints

func NewListConstraints(allowList []LogLevel) (*listConstraints, error)

NewListConstraints使用指定的容許級別建立一個新的listConstraints結構。這是一個個指明可以使用的級別類型

type LogLevelException

type LogLevelException struct {
    // contains filtered or unexported fields
}

LogLevelException表示當你須要一些特定的文件或函數來覆蓋常規約束並使用它們本身的約束時使用的例外狀況。即配置中的<exception>

func NewLogLevelException

func NewLogLevelException(funcPattern string, filePattern string, constraints logLevelConstraints) (*LogLevelException, error)

NewLogLevelException建立一個新的例外.第一個參數指明該例外用於的函數須要知足的模式，第二個參數指明該例外用於的文件須要知足的模式，第三個例外則是指明該例外的日誌級別限制，可以使用NewMinMaxConstraints函數和NewListConstraints函數的返回值

func NewAsyncLoopLogger

func NewAsyncLoopLogger(config *logConfig) *asyncLoopLogger

NewAsyncLoopLogger建立一個新的異步循環記錄器，聲明該seelog使用的是異步循環，即等價於配置中的<seelog type="asyncloop">。使用了這個函數就可以生成一個完整的seelog配置了

func NewLoggerConfig

func NewLoggerConfig(c logLevelConstraints, e []*LogLevelException, d dispatcherInterface) *logConfig

生成一個日誌記錄器的配置信息，用來做爲NewAsyncLoopLogger函數的輸入。第一個參數是該日誌記錄器的日誌級別限制，可使用NewMinMaxConstraints函數和NewListConstraints函數的返回值；第二個參數是使用的例外的例外對象列表；第三個參數是指定了格式format和輸出方式的分配器，即NewSplitDispatcher函數的返回值

4.其餘函數：

1）New* 類型函數

1》指明所用的type類型，如上面的NewAsyncLoopLogger函數做用：

func NewSyncLogger

func NewSyncLogger(config *logConfig) *syncLogger

NewSyncLogger建立一個同步的日誌記錄器，至關於配置中的<seelog type="sync">。第一個參數使用的是NewLoggerConfig函數的返回值，指明日誌級別限制、例外和指定了格式format和輸出方式的分配器

func NewAsyncAdaptiveLogger

func NewAsyncAdaptiveLogger(
    config *logConfig,
    minInterval time.Duration,
    maxInterval time.Duration,
    criticalMsgCount uint32) (*asyncAdaptiveLogger, error)

NewAsyncLoopLogger建立一個異步適應性生成器，至關於配置中的<seelog type="adaptive" mininterval="200000000" maxinterval="1000000000" critmsgcount="5">，第一個參數使用的是NewLoggerConfig函數的返回值，指明日誌級別限制、例外和指定了格式format和輸出方式的分配器；第二個和第三個參數指定計時器最小和最大時間間隔；第四個參數爲關鍵消息計數

func NewAsyncTimerLogger

func NewAsyncTimerLogger(config *logConfig, interval time.Duration) (*asyncTimerLogger, error)

NewAsyncLoopLogger建立一個異步循環日誌記錄器，即至關於配置中的<seelog type="asynctimer" asyncinterval="5000">，第一個參數使用的是NewLoggerConfig函數的返回值，指明日誌級別限制、例外和指定了格式format和輸出方式的分配器；第二個參數指明的是計數器的時間間隔，即asyncinterval

2》接收器，即指定日誌輸出的形式，如上面的NewConsoleWriter

func NewBufferedWriter

func NewBufferedWriter(innerWriter io.Writer, bufferSize int, flushPeriod time.Duration) (*bufferedWriter, error)

NewBufferedWriter建立一個新的緩衝寫入器結構，即配置中的<buffered size="10000" flushperiod="1000">。第一個參數指定在寫入內存同時寫入的文件對象；第二個參數bufferSize以字節爲單位的內存緩衝區的大小，0 則表示關閉此功能；第三個參數即指定的緩衝區刷新之間的間隔

func NewConnWriter

func NewConnWriter(netName string, addr string, reconnectOnMsg bool) *connWriter

在網絡netName上建立地址addr的寫入器，至關於配置的<conn formatid="syslog" net="tcp4" addr="server.address:5514" tls="true" insecureskipverify="true" />。第一個參數指定使用的網絡類型，即對應的net；第二個參數指定網絡地址；第三個參數若是reconnectOnMsg = true，將在每次寫入時打開鏈接

func NewFileWriter

func NewFileWriter(fileName string) (writer *fileWriter, err error)

建立一個新文件和相應的寫入器。若是沒法建立文件就會返回錯誤。至關於配置中的<file path="log.log"/>，第一個參數用於指明日誌文件的名字

func NewFormattedWriter

func NewFormattedWriter(writer io.Writer, formatter *formatter) (*formattedWriter, error)

func NewRollingFileWriterSize

func NewRollingFileWriterSize(fpath string, atype rollingArchiveType, apath string, maxSize int64, maxRolls int, namemode rollingNameMode, archiveExploded bool) (*rollingFileWriterSize, error)

至關於配置中<rollingfile type="size" filename="logs/roll.log" maxsize="1000" maxrolls="5" />，type爲size。第一個參數指定回滾文件的路徑；第二個參數指定存儲舊卷而不是刪除舊卷的存檔的類型，至關於archivetype；第三個參數即指定存儲舊卷的存檔的路徑，至關於archivepath；第四個參數爲指定文件最大字節數；第五個參數爲滾動文件的命名模式，至關於配置的namemode；第六個參數用於用於指定日誌是應該被分解仍是分組到同一個歸檔文件中

func NewRollingFileWriterTime

func NewRollingFileWriterTime(fpath string, atype rollingArchiveType, apath string, maxr int,
    timePattern string, namemode rollingNameMode, archiveExploded bool, fullName bool) (*rollingFileWriterTime, error)

至關於配置中的<rollingfile type="date" filename="logs/roll.log" datepattern="02.01.2006" maxrolls="7" />，type爲date。第四個參數爲指定文件中的最大行數；第五個參數指定輸出在文件中時間的格式

func NewSMTPWriter

func NewSMTPWriter(sa, sn string, ras []string, hn, hp, un, pwd string, cacdps []string, subj string, headers []string) *smtpWriter

NewSMTPWriter 返回一個新的SMTP寫入器，至關於配置中的<smtp senderaddress="noreply-notification-service@none.org" sendername="Automatic notification service" hostname="mail.none.org" hostport="587" username="nns" password="123">。sa,sn對應的就是senderaddress，sendername；ras即配置中子元素recipient的address能夠有多個因此爲列表，如：

    <recipient address="john-smith@none.com"/>
    <recipient address="hans-meier@none.com"/>

hn, hp, un, pwd對應的是hostname，hostport，username，password；cacdps即子元素cacertdirpath中的path值，如<cacertdirpath path="cacdp1"/>；subj即subject-電子郵件的主題；headers即該郵件的頭消息，能夠有多個值，因此爲列表，如：

<header name="Priority" value="Urgent" />
<header name="Importance" value="high" />

3》分配器，如上面的NewSplitDispatcher函數

func NewFilterDispatcher

func NewFilterDispatcher(formatter *formatter, receivers []interface{}, allowList ...LogLevel) (*filterDispatcher, error)

NewFilterDispatcher使用容許的級別列表建立一個新的filterDispatcher，至關於配置中的<filter levels="trace,debug">。

下面是自定義的分配器

func NewCustomReceiverDispatcher

func NewCustomReceiverDispatcher(formatter *formatter, customReceiverName string, cArgs CustomReceiverInitArgs) (*customReceiverDispatcher, error)

NewCustomReceiverDispatcher建立一個customReceiverDispatcher，它將數據分派到配置文件中使用<custom>標記建立的特定接收器。

func NewCustomReceiverDispatcherByValue

func NewCustomReceiverDispatcherByValue(formatter *formatter, customReceiver CustomReceiver, name string, cArgs CustomReceiverInitArgs) (*customReceiverDispatcher, error)

NewCustomReceiverDispatcherByValue基本上與NewCustomReceiverDispatcher相同，可是使用特定的CustomReceiver值而不是按類型實例化一個新值

4》格式化，如上面的NewFormatter函數

5》限制，如上面的NewListConstraints和NewMinMaxConstraints

func NewOffConstraints

func NewOffConstraints() (*offConstraints, error)

「off」日誌級別

「off」是一個特殊的日誌級別，它意味着禁用日誌記錄。它能夠在minlevel和level約束中使用，所以你能夠在全局約束或例外約束中寫入'minlevel= 「off」'和'levels= 「off」'來禁用日誌。

2）常量

1》日誌級別

const (
    TraceLvl = iota //0
    DebugLvl         //1
    InfoLvl 
    WarnLvl
    ErrorLvl
    CriticalLvl
    Off                  //6
)

2》日誌級別字符串表示（使用在配置文件中）

const (
    TraceStr    = "trace"
    DebugStr    = "debug"
    InfoStr     = "info"
    WarnStr     = "warn"
    ErrorStr    = "error"
    CriticalStr = "critical"
    OffStr      = "off"
)

3》使用 %Date和%Time別名表示的日期和時間的格式化

const (
    DateDefaultFormat = "2006-01-02"
    TimeFormat        = "15:04:05"
)

4》FormatterSymbol是配置文件中用於標記特殊格式別名的特殊符號。

const (
    FormatterSymbol = '%'
)

5》MaxQueueSize是隊列中致使當即刷新的消息的關鍵數量。

const (
    MaxQueueSize = 10000
)

6》發送SMTP時的默認subject

const (
    // Default subject phrase for sending emails.
    DefaultSubjectPhrase = "Diagnostic message from server: "
)

3）變量

var (
    DefaultFormatter *formatter
)
var DefaultMsgFormat = "%Ns [%Level] %Msg%n"

默認使用的日誌消息的輸出格式，即時間 [日誌級別] 日誌消息換行符

4）輸出日誌函數

func Critical

func Critical(v ...interface{}) error

Critical使用其操做數的默認格式來格式消息，並寫入日誌級別= Critical的默認日誌記錄器

func Criticalf

func Criticalf(format string, params ...interface{}) error

Criticalf根據格式說明符format格式化消息，並使用日誌級別 = Critical寫入默認日誌記錄器

func Debug

func Debug(v ...interface{})

Debug使用其操做數的默認格式來格式化消息，並使用日誌級別= Debug將消息寫入默認日誌記錄器

func Debugf

func Debugf(format string, params ...interface{})

Debugf根據格式說明符格式化消息，並使用日誌級別 = Debug寫入默認日誌記錄器。

func Error

func Error(v ...interface{}) error

Error使用其操做數的默認格式來格式化消息，並使用日誌級別= Error寫入默認日誌記錄器

func Errorf

func Errorf(format string, params ...interface{}) error

Errorf根據格式說明符format來格式化消息，並使用日誌級別= Error寫入默認日誌記錄器

func Info

func Info(v ...interface{})

Info 信息使用其操做數的默認格式來格式化消息，並使用日誌級別 = Info寫入默認日誌記錄器

func Infof

func Infof(format string, params ...interface{})

Infof根據格式說明符來格式化消息，並使用日誌級別= Info寫入默認日誌記錄器。

func Trace

func Trace(v ...interface{})

Trace使用其操做數的默認格式來格式化消息，並使用日誌級別= Trace寫入默認日誌記錄器

func Tracef

func Tracef(format string, params ...interface{})

Tracef根據格式說明符來格式化消息，並使用日誌級別= Trace寫入默認日誌記錄器。

func Warn

func Warn(v ...interface{}) error

Warn使用其操做數的默認格式來格式化消息，並使用日誌級別= Warn寫入默認日誌記錄器

func Warnf

func Warnf(format string, params ...interface{}) error

Warnf根據格式說明符來格式化消息，並使用日誌級別 = Warn寫入默認日誌記錄器

舉例：

package main

import log "github.com/cihub/seelog"

func main() {
    testConfig := `
<seelog type="sync" minlevel="trace">
    <outputs><console/></outputs>
</seelog>`

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

    log.Trace("NOT Printed")
    log.Tracef("Returning %s", "NOT Printed")
    log.Debug("NOT Printed")
    log.Debugf("Returning %s", "NOT Printed")
    log.Info("Printed")
    log.Infof("Returning %s", "Printed")
    log.Warn("Printed")
    log.Warnf("Returning %s", "Printed")
    log.Error("Printed")
    log.Errorf("Returning %s", "Printed")
    log.Critical("Printed")
    log.Criticalf("Returning %s", "Printed")
}

userdeMBP:go-learning user$ go run test.go 
1551777220280758000 [Trace] NOT Printed
1551777220280819000 [Trace] Returning NOT Printed
1551777220280842000 [Debug] NOT Printed
1551777220280848000 [Debug] Returning NOT Printed
1551777220280853000 [Info] Printed
1551777220280858000 [Info] Returning Printed
1551777220280863000 [Warn] Printed
1551777220280871000 [Warn] Returning Printed
1551777220280876000 [Error] Printed
1551777220280885000 [Error] Returning Printed
1551777220280891000 [Critical] Printed
1551777220280896000 [Critical] Returning Printed

5）

func Flush

func Flush()

Flush當即處理全部當前排隊的消息和全部當前緩衝的消息。它是一個阻塞調用，僅在隊列爲空且全部緩衝區爲空時才返回。
若是同步日誌程序調用Flush (type='sync')，它只刷新緩衝區(例如'<buffered>' 接收器)，由於沒有隊列。
當你的應用程序將要關閉時，調用這個方法能夠保證不丟失任何日誌消息。因此必定要在最後調用該函數

func UseLogger

func UseLogger(logger LoggerInterface) error

UseLogger將 'Current'包級別的日誌記錄器變量設置爲指定值。此變量用於全部Trace/Debug/... 包級功能。

⚠️:UseLogger不關閉前一個日誌記錄器(只刷新它)。所以，若是你常用它來替換日誌記錄程序，而不是在其餘代碼中關閉它們，那麼最終將致使內存泄漏。
要安全地替換日誌記錄器，請使用ReplaceLogger。

若是你調用了：

seelog.UseLogger(somelogger)

以後你再調用：

seelog.Debug("abc")

它其實久等價於：

somelogger.Debug("abc")

func ReplaceLogger

func ReplaceLogger(logger LoggerInterface) error

ReplaceLogger充當UseLogger，可是之前使用的日誌記錄器會被銷燬(默認和禁用的日誌記錄器除外)。

舉例：

package main

import log "github.com/cihub/seelog"

func main() {
    log.Info("Replace before Printed") //使用的是默認的格式
    testConfig := `
<seelog type="sync" minlevel="info">
    <outputs formatid="main"><console/></outputs>
    <formats>
        <format id="main" format="%UTCDate %UTCTime - [%LEV] - %RelFile - l%Line - %Msg%n"></format>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig)) 
    log.ReplaceLogger(logger) //替換後使用的就是上面新定義的格式了
    defer log.Flush()

    log.Info("Replace after Printed")
}

userdeMBP:go-learning user$ go run test.go 
1551777876234048000 [Info] Replace before Printed
2019-03-05 09:24:36 - [INF] - test.go - l20 - Replace after Printed

6）日誌級別

type LogLevel

type LogLevel uint8

日誌級別類型

func LogLevelFromString

func LogLevelFromString(levelStr string) (level LogLevel, found bool)

LogLevelFromString解析字符串，若是成功就返回字符串相應的日誌級別。

func (LogLevel) String

func (level LogLevel) String() string

LogLevelToString返回指定級別的seelog字符串表示形式。返回「」用於無效的日誌級別。

7）日誌級別例外

以前上面也講到了，即

type LogLevelException

type LogLevelException struct { // contains filtered or unexported fields }

LogLevelException表示當你須要一些特定的文件或函數來覆蓋常規約束並使用它們本身的約束時使用的例外狀況。即配置中的<exception>

func NewLogLevelException

func NewLogLevelException(funcPattern string, filePattern string, constraints logLevelConstraints) (*LogLevelException, error)

而後下面是一些讀取定義的例外中的一些值的方法：

func (*LogLevelException) FilePattern

func (logLevelEx *LogLevelException) FilePattern() string

FilePattern返回例外的文件模式

對應配置中的：

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

func (*LogLevelException) FuncPattern

func (logLevelEx *LogLevelException) FuncPattern() string

FuncPattern返回例外的函數模式

對應配置中的：

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

func (*LogLevelException) IsAllowed

func (logLevelEx *LogLevelException) IsAllowed(level LogLevel) bool

若是此LogLevelException的約束是容許指定的level日誌級別的，那麼IsAllowed將返回true

func (*LogLevelException) MatchesContext

func (logLevelEx *LogLevelException) MatchesContext(context LogContextInterface) bool

若是上下文context匹配此LogLevelException的模式，則MatchesContext返回true

func (*LogLevelException) String

func (logLevelEx *LogLevelException) String() string

8）LoggerInterface日誌記錄器接口

type LoggerInterface

type LoggerInterface interface {

    // Tracef formats message according to format specifier
    // and writes to log with level = Trace.
    Tracef(format string, params ...interface{})

    // Debugf formats message according to format specifier
    // and writes to log with level = Debug.
    Debugf(format string, params ...interface{})

    // Infof formats message according to format specifier
    // and writes to log with level = Info.
    Infof(format string, params ...interface{})

    // Warnf formats message according to format specifier
    // and writes to log with level = Warn.
    Warnf(format string, params ...interface{}) error

    // Errorf formats message according to format specifier
    // and writes to log with level = Error.
    Errorf(format string, params ...interface{}) error

    // Criticalf formats message according to format specifier
    // and writes to log with level = Critical.
    Criticalf(format string, params ...interface{}) error

    // Trace formats message using the default formats for its operands
    // and writes to log with level = Trace
    Trace(v ...interface{})

    // Debug formats message using the default formats for its operands
    // and writes to log with level = Debug
    Debug(v ...interface{})

    // Info formats message using the default formats for its operands
    // and writes to log with level = Info
    Info(v ...interface{})

    // Warn formats message using the default formats for its operands
    // and writes to log with level = Warn
    Warn(v ...interface{}) error

    // Error formats message using the default formats for its operands
    // and writes to log with level = Error
    Error(v ...interface{}) error

    // Critical formats message using the default formats for its operands
    // and writes to log with level = Critical
    Critical(v ...interface{}) error

    // Close flushes all the messages in the logger and closes it. It cannot be used after this operation.
    Close()

    // Flush flushes all the messages in the logger.
    Flush()

    // Closed returns true if the logger was previously closed.
    Closed() bool

    // SetAdditionalStackDepth sets the additional number of frames to skip by runtime.Caller
    // when getting function information needed to print seelog format identifiers such as %Func or %File.
    //
    // This func may be used when you wrap seelog funcs and want to print caller info of you own
    // wrappers instead of seelog func callers. In this case you should set depth = 1. If you then
    // wrap your wrapper, you should set depth = 2, etc.
    //
    // NOTE: Incorrect depth value may lead to errors in runtime.Caller evaluation or incorrect
    // function/file names in log files. Do not use it if you are not going to wrap seelog funcs.
    // You may reset the value to default using a SetAdditionalStackDepth(0) call.
    SetAdditionalStackDepth(depth int) error

    // Sets logger context that can be used in formatter funcs and custom receivers
    SetContext(context interface{})
    // contains filtered or unexported methods
}

LoggerInterface表示可以記錄Seelog消息的結構，即只有實現了接口中全部函數才能做爲一個logger

var Current LoggerInterface

Current是用於全部包級別的便利功能(如 'Trace', 'Debug', 'Flush'等)中的日誌程序。

var Default LoggerInterface

默認日誌記錄器，它是由一個空配置「<seelog/>」建立的。它不是由ReplaceLogger調用關閉的。

var Disabled LoggerInterface

禁用的日誌記錄器，在任何狀況下都不會產生任何輸出。它既不會被ReplaceLogger調用關閉，也不會被刷新。

生成日誌記錄器的幾種方法，這裏只講其中幾種：

func LoggerFromConfigAsBytes

func LoggerFromConfigAsBytes(data []byte) (LoggerInterface, error)

LoggerFromConfigAsBytes使用來自字節流的配置建立一個日誌記錄器。字節應該包含有效的seelog xml。

舉例：

package main

import log "github.com/cihub/seelog" func main() { log.Info("Replace before Printed") //使用的是默認的格式 testConfig := ` <seelog type="sync" minlevel="info"> <outputs formatid="main"><console/></outputs> <formats> <format id="main" format="%UTCDate %UTCTime - [%LEV] - %RelFile - l%Line - %Msg%n"></format> </formats> </seelog>` logger, _ := log.LoggerFromConfigAsBytes([]byte(testConfig)) log.ReplaceLogger(logger) //替換後使用的就是上面新定義的格式了  defer log.Flush() log.Info("Replace after Printed") }

userdeMBP:go-learning user$ go run test.go 
1551777876234048000 [Info] Replace before Printed 2019-03-05 09:24:36 - [INF] - test.go - l20 - Replace after Printed

func LoggerFromConfigAsFile

func LoggerFromConfigAsFile(fileName string) (LoggerInterface, error)

LoggerFromConfigAsFile使用配置文件建立日誌記錄器。文件應該包含有效的seelog xml。

舉例：

其實就是將配置信息xml寫到seelog.xml文件中：

<seelog type="sync" minlevel="info">
    <outputs formatid="main"><console/></outputs>
    <formats>
        <format id="main" format="%UTCDate %UTCTime - [%LEV] - %RelFile - l%Line - %Msg%n"></format>
    </formats>
</seelog>

而後示例爲：

package main

import log "github.com/cihub/seelog"

func main() {
    log.Info("Replace before Printed") //使用的是默認的格式

    logger, _ := log.LoggerFromConfigAsFile("seelog.xml")
    log.ReplaceLogger(logger) //替換後使用的就是上面新定義的格式了
    defer log.Flush()

    log.Info("Replace after Printed")
}

返回結果和上面相似

func LoggerFromConfigAsString

func LoggerFromConfigAsString(data string) (LoggerInterface, error)

LoggerFromConfigAsString使用配置從字符串建立一個日誌記錄器。字符串應該包含有效的seelog xml。

package main

import log "github.com/cihub/seelog"

func main() {
    log.Info("Replace before Printed") //使用的是默認的格式
    testConfig := `
<seelog type="sync" minlevel="info">
    <outputs formatid="main"><console/></outputs>
    <formats>
        <format id="main" format="%UTCDate %UTCTime - [%LEV] - %RelFile - l%Line - %Msg%n"></format>
    </formats>
</seelog>`

    logger, _ := log.LoggerFromConfigAsString(testConfig)
    log.ReplaceLogger(logger) //替換後使用的就是上面新定義的格式了
    defer log.Flush()

    log.Info("Replace after Printed")
}