logger

type Accumulator ¶

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

Accumulator is a thread safe object implementing the Logger interface that accumulates all messages being logged.

You can then use the Retrieve() or Forward() methods to access or print the accumulated messages.

func NewAccumulator() *Accumulator

func (dl *Accumulator) Add(prio Priority, format string, args ...interface{})

func (dl *Accumulator) Debugf(format string, args ...interface{})

func (dl *Accumulator) Errorf(format string, args ...interface{})

func (dl *Accumulator) Forward(log Logger)

func (dl *Accumulator) ForwardWithPrinter(log Logger, printer func(*Event, Logger))

func (dl *Accumulator) Infof(format string, args ...interface{})

func (dl *Accumulator) Retrieve() []Event

func (dl *Accumulator) SetOutput(writer io.Writer)

func (dl *Accumulator) Warnf(format string, args ...interface{})

type DefaultLogger ¶

type DefaultLogger struct {
	Printer Printer
	Setter  func(writer io.Writer)
}

DefaultLogger uses a single Printf to implement the Logger interface.

Printer must be provided. Use log.Printf to rely on default golang logging, with:

logger := &DefaultLoger{Printer: log.Printf}

... or just use the pre-defined `Go` variable bleow for default Go logging.

func (dl DefaultLogger) Debugf(format string, args ...interface{})

func (dl DefaultLogger) Errorf(format string, args ...interface{})

func (dl DefaultLogger) Infof(format string, args ...interface{})

func (dl DefaultLogger) Printf(format string, args ...interface{})

func (dl DefaultLogger) SetOutput(output io.Writer)

func (dl DefaultLogger) Warnf(format string, args ...interface{})

type Event ¶

type Event struct {
	Time     time.Time
	Priority Priority
	Message  string
}

Event represents something that was logged.

type Forwardable ¶

type Forwardable interface {
	Forward(Logger)
}

Forwardable is the interface implemented by any logger capable of forwarding, upon request, buffered messages to another logger.

type IndentedError ¶

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

IndentedError reformats the error to have indented new lines.

func NewIndentedError(err error, indent string) *IndentedError

An error occured in executing function, stack trace follows.
  Function1() ...
  Function2() ...

| An error occured in executing function, stack trace follows.
|   Function1() ...
|   Function2() ...

func (ie *IndentedError) Error() string

func (ie *IndentedError) Unwrap() error

type Logger ¶

type Logger interface {
	// Use for messages that are pretty much only useful when debugging
	// specific behaviors. Should be used rarely.
	// Expect debug messages to be discarded.
	Debugf(format string, args ...interface{})
	// Use for messages that clearly a) outline a problem that b) the operator MUST act upon.
	// Errors are generally reserved for things that cause the program to fail and must be fixed.
	Errorf(format string, args ...interface{})
	// Use for messages that a) outline a problem that b) is actionable, and c) the operator
	// may want to act upon - even though the program may have recovered or continued without
	// intervention (in degraded mode, or without some functionality, ...).
	Warnf(format string, args ...interface{})
	// Use for messages that are either not actionable, or require no action by the operator.
	Infof(format string, args ...interface{})

	SetOutput(writer io.Writer)
}

Logger is the interface used by the enkit libraries to log messages.

The logrus library can be used out of the box without additional glue. The golang log library is used by default, through DefaultLogger. DefaultLogger can be used to pass an arbitrary log function as well.

var Go Logger = &DefaultLogger{Printer: log.Printf}

var Nil Logger = &NilLogger{}

func GetCtx(ctx context.Context) Logger

type NilLogger ¶

type NilLogger struct{}

NilLogger is a logger that discards all messages.

Prefer using logger.Nil to instantiating your copy of &NilLogger{}.

func (dl NilLogger) Debugf(format string, args ...interface{})

func (dl NilLogger) Errorf(format string, args ...interface{})

func (dl NilLogger) Infof(format string, args ...interface{})

func (dl NilLogger) Printf(format string, args ...interface{})

func (dl NilLogger) SetOutput(output io.Writer)

func (dl NilLogger) Warnf(format string, args ...interface{})

type Printer ¶

type Printer func(format string, args ...interface{})

Printer is a Printf like function.

type Priority ¶

type Priority int

Represents a logging priority. Logging priorities map to the Debugf, Infof, Warnf, and Errorf printers.

const (
	DebugPriority Priority = iota
	InfoPriority
	WarnPriority
	ErrorPriority
)

type Proxy ¶

type Proxy struct {
	Logger
}

Proxy is a simple logger that as long as it is passed by pointer, allows to change the underlying logger implementation.

This allows to initialize some code to use a logging object, to then replace it later after the initialization stage.

func (p *Proxy) Replace(newl Logger)