logger

README

Logger for golang

The goal of this little library is to provide a nice and easy to use logger with severity handling, flexible output and "context" handling. Currently the interface provides two convenience functions for each severity. One for logging plain strings, the other one with a Printf-like interface.

In contrast to the build-in "log" module, this library uses a logger instance, that needs to be passed around. Apart from the obvious drawback of needing to pass it around this provides the ability to inject a logger instance with additional information attached.

In the near future I plan to implement support for golang.org/x/net/context.

Currently you need to instanciate a log encoder, a log writer and the actual logger object

Usage

var (
	le logger.Encoder
	lw logger.Writer
	l  logger.Logger
)

le = logger.NewStringEncoder()
lw = logger.NewFileWriter(os.Stdout, logger.NewStringEncoder(), logger.Seperators.NewLine)
l = logger.NewLogger(w)

Motivation

I was very unhappy with all loggers I could find for the go language, as there wasn't a single one with usable severity handling. I've seen a lot of go programs writing "[WARN]" etc. as part of the literal log message which I find very appalling, because it introduces the need to parse strings if you wan't to do some automatic processing and/or filtering of log messages, or want to use something like the ELK stack.

Documentation

Index

• Constants
• Variables
• type Encoder
• type ExtraEncoder
• type FileWriter
  • func NewFileWriter(out io.Writer, e Encoder, separator []byte) *FileWriter
  • func (f *FileWriter) Write(m Message)
• type JsonEncoder
  • func NewJsonEncoder() JsonEncoder
  • func (j JsonEncoder) Encode(m Message) []byte
• type Logger
  • func NewLogger(writer Writer) *Logger
  • func (l *Logger) Alert(m string)
  • func (l *Logger) Alertf(m string, a ...interface{})
  • func (l *Logger) Critical(m string)
  • func (l *Logger) Criticalf(m string, a ...interface{})
  • func (l *Logger) Debug(m string)
  • func (l *Logger) Debugf(m string, a ...interface{})
  • func (l *Logger) Emergency(m string)
  • func (l *Logger) Emergencyf(m string, a ...interface{})
  • func (l *Logger) Error(m string)
  • func (l *Logger) Errorf(m string, a ...interface{})
  • func (l *Logger) Info(m string)
  • func (l *Logger) Infof(m string, a ...interface{})
  • func (l *Logger) Log(s Severity, m string)
  • func (l *Logger) Logf(s Severity, m string, additional ...interface{})
  • func (l *Logger) Notice(m string)
  • func (l *Logger) Noticef(m string, a ...interface{})
  • func (l *Logger) Trace(m string)
  • func (l *Logger) Tracef(m string, a ...interface{})
  • func (l *Logger) Warning(m string)
  • func (l *Logger) Warningf(m string, a ...interface{})
  • func (l *Logger) WithData(key string, value interface{}) *Logger
  • func (l *Logger) WithPrefix(p string) *Logger
• type Message
• type MessageExtra
• type MultiWriter
  • func NewMultiWriter(w ...Writer) *MultiWriter
  • func (m *MultiWriter) Add(w ...Writer)
  • func (m *MultiWriter) Write(msg Message)
• type Severity
  • func (s Severity) String() string
• type StringEncoder
  • func NewStringEncoder() StringEncoder
  • func (s StringEncoder) Encode(m Message) []byte
• type StringExtraEncoder
  • func NewStringExtraEncoder() *StringExtraEncoder
  • func (s *StringExtraEncoder) Encode(extra MessageExtra) []byte
• type WriteFilter
  • func NewWriteFilter(fn WriteFilterFn, writer Writer) *WriteFilter
  • func (w *WriteFilter) Write(msg Message)
• type WriteFilterFn
• type Writer
  • func NewSeverityFilter(min Severity, writer Writer) Writer

Constants

const (
	EMERGENCY = Severity(0)
	ALERT     = Severity(1)
	CRITICAL  = Severity(2)
	ERROR     = Severity(3)
	WARNING   = Severity(4)
	NOTICE    = Severity(5)
	INFO      = Severity(6)
	DEBUG     = Severity(7)
	TRACE     = Severity(8)
)

Variables

var (
	Seperators = seperators{
		Empty:   make([]byte, 0),
		NewLine: []byte("\n"),
	}
)

Types

type Encoder

type Encoder interface {
	Encode(Message) []byte
}

type ExtraEncoder

type ExtraEncoder interface {
	Encode(MessageExtra) []byte
}

type FileWriter

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

func NewFileWriter

func NewFileWriter(out io.Writer, e Encoder, separator []byte) *FileWriter

func (*FileWriter) Write

func (f *FileWriter) Write(m Message)

type JsonEncoder

type JsonEncoder struct {
}

func NewJsonEncoder

func NewJsonEncoder() JsonEncoder

func (JsonEncoder) Encode

func (j JsonEncoder) Encode(m Message) []byte

type Logger

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

func NewLogger

func NewLogger(writer Writer) *Logger

func (*Logger) Alert

func (l *Logger) Alert(m string)

func (*Logger) Alertf

func (l *Logger) Alertf(m string, a ...interface{})

func (*Logger) Critical

func (l *Logger) Critical(m string)

func (*Logger) Criticalf

func (l *Logger) Criticalf(m string, a ...interface{})

func (*Logger) Debug

func (l *Logger) Debug(m string)

func (*Logger) Debugf

func (l *Logger) Debugf(m string, a ...interface{})

func (*Logger) Emergency

func (l *Logger) Emergency(m string)

func (*Logger) Emergencyf

func (l *Logger) Emergencyf(m string, a ...interface{})

func (*Logger) Error

func (l *Logger) Error(m string)

func (*Logger) Errorf

func (l *Logger) Errorf(m string, a ...interface{})

func (*Logger) Info

func (l *Logger) Info(m string)

func (*Logger) Infof

func (l *Logger) Infof(m string, a ...interface{})

func (*Logger) Log

func (l *Logger) Log(s Severity, m string)

func (*Logger) Logf

func (l *Logger) Logf(s Severity, m string, additional ...interface{})

func (*Logger) Notice

func (l *Logger) Notice(m string)

func (*Logger) Noticef

func (l *Logger) Noticef(m string, a ...interface{})

func (*Logger) Trace

func (l *Logger) Trace(m string)

func (*Logger) Tracef

func (l *Logger) Tracef(m string, a ...interface{})

func (*Logger) Warning

func (l *Logger) Warning(m string)

func (*Logger) Warningf

func (l *Logger) Warningf(m string, a ...interface{})

func (*Logger) WithData

func (l *Logger) WithData(key string, value interface{}) *Logger

func (*Logger) WithPrefix

func (l *Logger) WithPrefix(p string) *Logger

type Message

type Message struct {
	Time     time.Time
	Severity Severity
	Message  string
	Extra    MessageExtra
}

type MessageExtra

type MessageExtra map[string]interface{}

type MultiWriter

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

func NewMultiWriter

func NewMultiWriter(w ...Writer) *MultiWriter

func (*MultiWriter) Add

func (m *MultiWriter) Add(w ...Writer)

func (*MultiWriter) Write

func (m *MultiWriter) Write(msg Message)

type Severity

type Severity int

func (Severity) String

func (s Severity) String() string

type StringEncoder

type StringEncoder struct {
	Format       string
	DateFormat   string
	ExtraEncoder ExtraEncoder
}

func NewStringEncoder

func NewStringEncoder() StringEncoder

func (StringEncoder) Encode

func (s StringEncoder) Encode(m Message) []byte

type StringExtraEncoder

type StringExtraEncoder struct {
	OuterFormat string
	ItemFormat  string
	Glue        string
}

func NewStringExtraEncoder

func NewStringExtraEncoder() *StringExtraEncoder

func (*StringExtraEncoder) Encode

func (s *StringExtraEncoder) Encode(extra MessageExtra) []byte

type WriteFilter

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

func NewWriteFilter

func NewWriteFilter(fn WriteFilterFn, writer Writer) *WriteFilter

func (*WriteFilter) Write

func (w *WriteFilter) Write(msg Message)

type WriteFilterFn

type WriteFilterFn func(Message) (Message, bool)

type Writer

type Writer interface {
	Write(Message)
}

func NewSeverityFilter

func NewSeverityFilter(min Severity, writer Writer) Writer