logging

Documentation

Index

• func Colors(keyvals ...interface{}) term.FgBgColor
• func Msg(logger kitlog.Logger, message string, keyvals ...interface{}) error
• func TraceValuer() kitlog.Valuer
• type Logger
  • func NewLogger(outputLogger kitlog.Logger) *Logger
  • func NewNoopLogger() *Logger
  • func WithMetadata(logger *Logger) *Logger
  • func (l *Logger) InfoMsg(message string, keyvals ...interface{}) error
  • func (l *Logger) SwapOutput(infoLogger kitlog.Logger)
  • func (l *Logger) TraceMsg(message string, keyvals ...interface{}) error
  • func (l *Logger) With(keyvals ...interface{}) *Logger
  • func (l *Logger) WithInfo(keyvals ...interface{}) *Logger
  • func (l *Logger) WithPrefix(keyvals ...interface{}) *Logger
  • func (l *Logger) WithScope(scopeName string) *Logger
  • func (l *Logger) WithTrace(keyvals ...interface{}) *Logger

Functions

func Colors

func Colors(keyvals ...interface{}) term.FgBgColor

func Msg

func Msg(logger kitlog.Logger, message string, keyvals ...interface{}) error

Record a structured log line with a message

func TraceValuer

func TraceValuer() kitlog.Valuer

Types

type Logger

type Logger struct {
	// Send a log message to the Info channel, formed of a sequence of key value
	// pairs. Info messages should be operationally interesting to a human who is
	// monitoring the logs. But not necessarily a human who is trying to
	// understand or debug the system. Any handled errors or warnings should be
	// sent to the Info channel (where you may wish to tag them with a suitable
	// key-value pair to categorise them as such).
	Info kitlog.Logger
	// Send an log message to the Trace channel, formed of a sequence of key-value
	// pairs. Trace messages can be used for any state change in the system that
	// may be of interest to a machine consumer or a human who is trying to debug
	// the system or trying to understand the system in detail. If the messages
	// are very point-like and contain little structure, consider using a metric
	// instead.
	Trace  kitlog.Logger
	Output *kitlog.SwapLogger
}

InfoTraceLogger maintains provides two logging 'channels' that are interlaced to provide a coarse grained filter to distinguish human-consumable 'Info' messages and execution level 'Trace' messages.

func NewLogger

func NewLogger(outputLogger kitlog.Logger) *Logger

Create an InfoTraceLogger by passing the initial outputLogger.

func NewNoopLogger

func NewNoopLogger() *Logger

func WithMetadata

func WithMetadata(logger *Logger) *Logger

func (*Logger) InfoMsg

func (l *Logger) InfoMsg(message string, keyvals ...interface{}) error

Record structured Info lo`g line with a message

func (*Logger) SwapOutput

func (l *Logger) SwapOutput(infoLogger kitlog.Logger)

Hot swap the underlying outputLogger with another one to re-route messages

func (*Logger) TraceMsg

func (l *Logger) TraceMsg(message string, keyvals ...interface{}) error

Record structured Trace log line with a message

func (*Logger) With

func (l *Logger) With(keyvals ...interface{}) *Logger

A logging context (see go-kit log's Context). Takes a sequence key values via With or WithPrefix and ensures future calls to log will have those contextual values appended to the call to an underlying logger. Values can be dynamic by passing an instance of the kitlog.Valuer interface This provides an interface version of the kitlog.Context struct to be used For implementations that wrap a kitlog.Context. In addition it makes no assumption about the name or signature of the logging method(s). See InfoTraceLogger

func (*Logger) WithInfo

func (l *Logger) WithInfo(keyvals ...interface{}) *Logger

Establish a context on the Info channel keeping Trace the same

func (*Logger) WithPrefix

func (l *Logger) WithPrefix(keyvals ...interface{}) *Logger

func (*Logger) WithScope

func (l *Logger) WithScope(scopeName string) *Logger

Establish or extend the scope of this logger by appending scopeName to the Scope vector. Like With the logging scope is append only but can be used to provide parenthetical scopes by hanging on to the parent scope and using once the scope has been exited. The scope mechanism does is agnostic to the type of scope so can be used to identify certain segments of the call stack, a lexical scope, or any other nested scope.

func (*Logger) WithTrace

func (l *Logger) WithTrace(keyvals ...interface{}) *Logger

Establish a context on the Trace channel keeping Info the same