README
¶
logplug
This package enables json output, level logging and so on to standard logger.
Usage
log.SetOutput(logplug.NewJSONPlug(os.Stderr,
logplug.LogFlag(log.LstdFlags),
logplug.Hooks(
logplug.LevelHook(logplug.LevelConfig{
Levels: []logplug.Level{"DBG", "INFO", "WARN", "ERR"},
Min: "INFO",
}),
)))
log.Printf("[INFO]output test")
// output: {"level":"INFO","message":"output test"}
// key and value in [] in prefix are used as custom field
log.SetPrefix("[label:test]")
log.Printf("[DBG] debug log")
// output: {"label":"test","level":"DBG","message":"debug log"}
Options
Examples
License
MIT
Documentation
¶
Overview ¶
Package logplug implements a plug of standard logging package. This package enables json output, level logging and so on to standard logger.
Plug implements io.Writer. Therefore, Plug can be specified as the output destination of log. Plug converts the output of log to the following format.
log.SetFlags(log.Ldate | log.Lshortfile)
log.Print("log message")
// normal output: "[label:test] 2006-01-02 doc.go:1:log message""
// convert:
map[string]interface{}{
"message": "logMessage",
"timestamp": time.Date(2006,1,2,0,0,0,0,0,time.Local),
"location": "doc.go:1",
}
Pass the converted map to the encoder as an argument. Therefore, you can change the output format of log by the encoder of Plug.
log.SetOutput(log.NewJSONPlug(os.Stderr))
log.Print("output")
// output: {"message":"output"}
Use prefix if you want to use the log to include custom fields. Custom fields set the values in [] as key and value.
log.Printf("[key:value] custom")
// convert:
map[string]interface{}{
"key": "value",
"message": "custom",
}
You can use SetPrefix to set fields that are common to all logs.
log.SetPrefix("[key]:value")
log.Printf("custom")
// convert:
map[string]interface{}{
"key": "value",
"message": "custom",
}
It supports hooks before encoding. Hooks allow level logging, field changes and so on.
logplug.NewJSONPlug(os.Stderr, logplug.Hooks(
logplug.LevelHook(logplug.LevelConfig{
Levels: []logplug.Level{"DBG", "INFO", "WARN", "ERR"},
Min: "INFO",
}),
))
Example (GlobalLogger) ¶
package main
import (
"log"
"os"
"github.com/komem3/logplug"
)
func main() {
log.SetOutput(logplug.NewJSONPlug(os.Stderr,
logplug.LogFlag(log.LstdFlags),
logplug.Hooks(
logplug.LevelHook(logplug.LevelConfig{
Levels: []logplug.Level{"DBG", "INFO", "WARN", "ERR"},
Min: "INFO",
}),
)))
log.Printf("[INFO]output test")
}
Output:
Example (LocalLogger) ¶
package main
import (
"log"
"os"
"github.com/komem3/logplug"
)
func main() {
l := log.New(logplug.NewJSONPlug(os.Stderr,
logplug.Hooks(
logplug.LevelHook(logplug.LevelConfig{
Levels: []logplug.Level{"DBUG", "INFO", "WARNING", "ERROR"},
Alias: logplug.LevelAlias{
"DBG": "DBUG",
"INFO": "INFO",
"WARN": "WARNING",
"ERR": "ERROR",
},
Field: "severity",
}),
),
logplug.LogFlag(log.Ldate|log.Lmicroseconds|log.Llongfile),
), "[trace:1000][span:20]", log.Ldate|log.Lmicroseconds|log.Llongfile)
l.Print("[ERR] output test")
}
Output:
Index ¶
- type Encoder
- type EncoderFunc
- type Hook
- type Level
- type LevelAlias
- type LevelConfig
- type MessageElement
- func (m *MessageElement) AddString(key string, v string)
- func (m *MessageElement) Elements() map[string]interface{}
- func (m *MessageElement) GetBool(key string) bool
- func (m *MessageElement) GetString(key string) string
- func (m *MessageElement) GetTime(key string) time.Time
- func (m *MessageElement) Set(key string, v interface{})
- type Option
- type Plug
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Encoder ¶
type Encoder interface {
Encode(p *Plug, m *MessageElement) error
}
Encoder defines a encode for each field in the log.
Example ¶
package main
import (
"encoding/csv"
"log"
"os"
"github.com/komem3/logplug"
)
type csvEncoder struct {
writer *csv.Writer
}
func (c *csvEncoder) Encode(p *logplug.Plug, m *logplug.MessageElement) error {
return c.writer.Write([]string{m.GetString("level"), m.GetString(p.MessageField())})
}
func main() {
csvwriter := csv.NewWriter(os.Stdout)
defer csvwriter.Flush()
err := csvwriter.Write([]string{"level", "message"})
if err != nil {
log.Fatal(err)
}
l := log.New(logplug.NewPlug(&csvEncoder{writer: csvwriter}, logplug.Hooks(
logplug.LevelHook(logplug.LevelConfig{
Levels: []string{"DBG", "INFO", "ERR"},
Field: "level",
}),
)), "", 0)
l.Print("[INFO]csv output")
}
Output: level,message INFO,csv output
type EncoderFunc ¶
type EncoderFunc func(p *Plug, m *MessageElement) error
EncoderFunc is adapter of Encoder.
func (EncoderFunc) Encode ¶
func (f EncoderFunc) Encode(p *Plug, m *MessageElement) error
Encode implements Encoder.
type Hook ¶
Hook is a hook of encoder.
Example ¶
package main
import (
"log"
"os"
"github.com/komem3/logplug"
)
func timeLayoutHook(layout string) logplug.Hook {
return func(enc logplug.Encoder) logplug.Encoder {
return logplug.EncoderFunc(func(p *logplug.Plug, m *logplug.MessageElement) error {
t := m.GetTime(p.TimestampField())
if t.IsZero() {
return enc.Encode(p, m)
}
m.Set(p.TimestampField(), t.Format(layout))
return enc.Encode(p, m)
})
}
}
func main() {
const layout = "2006/01/02"
l := log.New(logplug.NewJSONPlug(os.Stdout,
logplug.LogFlag(log.Ldate),
logplug.Hooks(timeLayoutHook(layout)),
), "", log.Ldate)
l.Print("time")
// out: {"message":"time","timestamp":"2006/01/02"}
}
Output:
func LevelHook ¶
func LevelHook(config LevelConfig) Hook
LevelHook is hook of parse level and level filter. LevelHook use the string in the first [] of the Message field as the level.
log.Print("[DBG] message") // level=DBG
If config.Default and config.Min are empty, set config.Levels[0].
simple:
logplug.LevelHook(logplug.LevelConfig{Levels: []logplug.Level{"DBG", "WARN", "ERR"}})
setting min level:
logplug.LevelHook(logplug.LevelConfig{Levels: []logplug.Level{"DBG","ERR"}, Min: "ERR"})
level alias(DBG -> DEBUG):
logplug.LevelHook(logplug.LevelConfig{Alias: logplug.LevelAlias{"DBG": "DEBUG"}})
type LevelConfig ¶
type LevelConfig struct {
Levels []Level
Default Level
Min Level
Alias LevelAlias
Field string
}
LevelConfig is option of LevelEncoder.
type MessageElement ¶
type MessageElement struct {
// contains filtered or unexported fields
}
MessageElement store elements of message.
func (*MessageElement) AddString ¶
func (m *MessageElement) AddString(key string, v string)
AddString add v to key of elements.
func (*MessageElement) Elements ¶
func (m *MessageElement) Elements() map[string]interface{}
func (*MessageElement) GetBool ¶
func (m *MessageElement) GetBool(key string) bool
func (*MessageElement) GetString ¶
func (m *MessageElement) GetString(key string) string
func (*MessageElement) Set ¶
func (m *MessageElement) Set(key string, v interface{})
Set set v to key of elements. This method override exist value. If you want to set string value, recommend to use AddString.
type Option ¶
type Option func(p *Plug)
Option is option of Plug.
func LocationField ¶
LocationField set field name of location.
func LogFlag ¶
LogFlag set flag of log. This value should match the value of flag of log.
see available flag:
go doc log.Ldate
func TimestampField ¶
TimestampField set field name of timestamp.
type Plug ¶
type Plug struct {
// contains filtered or unexported fields
}
Plug is standard log plug.
func NewJSONPlug ¶
NewJSONPlug create a plug that converts log to json.
Source Files
Directories