loggers

Documentation

Index

• Constants
• func Compose(handlers ...func(log.Logger) log.Logger) func(log.Logger) log.Logger
• func NewFilterLogger(outputLogger log.Logger, predicate func(keyvals []interface{}) bool) log.Logger
• func NewMultipleOutputLogger(outputLoggers ...log.Logger) log.Logger
• func NonBlockingLogger(outputLogger log.Logger) log.Logger
• func VectorValuedLogger(logger log.Logger) log.Logger
• type CaptureLogger
  • func NewCaptureLogger(outputLogger log.Logger, bufferCap channels.BufferCap, passthrough bool) *CaptureLogger
  • func (cl *CaptureLogger) BufferLogger() *ChannelLogger
  • func (cl *CaptureLogger) Flush()
  • func (cl *CaptureLogger) FlushLogLines() [][]interface{}
  • func (cl *CaptureLogger) Log(keyvals ...interface{}) error
  • func (cl *CaptureLogger) OutputLogger() log.Logger
  • func (cl *CaptureLogger) Passthrough() bool
  • func (cl *CaptureLogger) SetPassthrough(passthrough bool)
• type ChannelLogger
  • func NewChannelLogger(loggingRingBufferCap channels.BufferCap) *ChannelLogger
  • func (cl *ChannelLogger) BufferCap() channels.BufferCap
  • func (cl *ChannelLogger) BufferLength() int
  • func (cl *ChannelLogger) DrainForever(logger log.Logger)
  • func (cl *ChannelLogger) Flush(logger log.Logger)
  • func (cl *ChannelLogger) FlushLogLines() [][]interface{}
  • func (cl *ChannelLogger) Log(keyvals ...interface{}) error
  • func (cl *ChannelLogger) ReadLogLine() []interface{}
  • func (cl *ChannelLogger) Reset()
  • func (cl *ChannelLogger) WaitReadLogLine() []interface{}
• type MultipleOutputLogger
  • func (mol MultipleOutputLogger) Log(keyvals ...interface{}) error

Constants

const (
	DefaultLoggingRingBufferCap channels.BufferCap = 100
)

Functions

func Compose

func Compose(handlers ...func(log.Logger) log.Logger) func(log.Logger) log.Logger

Apply a pipeline of log handlers, the handlers will are applied with the from right to left so the earlier handlers are the outermost ones, so for an incoming message 'msg' and handlers 'h1', 'h2', 'h3': msg -> Compose(h1,h2,h3)(baseLogger) = msg -> h1 -> h2 -> h3 -> baseLogger

func NewFilterLogger

func NewFilterLogger(outputLogger log.Logger,
	predicate func(keyvals []interface{}) bool) log.Logger

Creates a logger that removes lines from output when the predicate evaluates true

func NewMultipleOutputLogger

func NewMultipleOutputLogger(outputLoggers ...log.Logger) log.Logger

Creates a logger that forks log messages to each of its outputLoggers

func NonBlockingLogger

func NonBlockingLogger(outputLogger log.Logger) log.Logger

Returns a Logger that wraps the outputLogger passed and does not block on calls to Log.

func VectorValuedLogger

func VectorValuedLogger(logger log.Logger) log.Logger

Types

type CaptureLogger

type CaptureLogger struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewCaptureLogger

func NewCaptureLogger(outputLogger log.Logger, bufferCap channels.BufferCap,
	passthrough bool) *CaptureLogger

Capture logger captures output set to it into a buffer logger and retains a reference to an output logger (the logger whose input it is capturing). It can optionally passthrough logs to the output logger. Because it holds a reference to its output it can also be used to coordinate Flushing of the buffer to the output logger in exceptional circumstances only

func (*CaptureLogger) BufferLogger

func (cl *CaptureLogger) BufferLogger() *ChannelLogger

The BufferLogger where the input into these CaptureLogger is stored in a ring buffer of log lines.

func (*CaptureLogger) Flush

func (cl *CaptureLogger) Flush()

Flushes every log line available in the buffer at the time of calling to the OutputLogger and returns. Does not block indefinitely.

Note: will remove log lines from buffer so they will not be produced on any subsequent flush of buffer

func (*CaptureLogger) FlushLogLines

func (cl *CaptureLogger) FlushLogLines() [][]interface{}

Flushes every log line available in the buffer at the time of calling to a slice and returns it. Does not block indefinitely.

Note: will remove log lines from buffer so they will not be produced on any subsequent flush of buffer

func (*CaptureLogger) Log

func (cl *CaptureLogger) Log(keyvals ...interface{}) error

func (*CaptureLogger) OutputLogger

func (cl *CaptureLogger) OutputLogger() log.Logger

The OutputLogger whose input this CaptureLogger is capturing

func (*CaptureLogger) Passthrough

func (cl *CaptureLogger) Passthrough() bool

Gets whether the CaptureLogger is forwarding log lines sent to through to its OutputLogger. Concurrently Safe.

func (*CaptureLogger) SetPassthrough

func (cl *CaptureLogger) SetPassthrough(passthrough bool)

Sets whether the CaptureLogger is forwarding log lines sent to it through to its output logger. Concurrently safe.

type ChannelLogger

type ChannelLogger struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewChannelLogger

func NewChannelLogger(loggingRingBufferCap channels.BufferCap) *ChannelLogger

Creates a Logger that uses a uses a non-blocking ring buffered channel. This logger provides a common abstraction for both a buffered, flushable logging cache. And a non-blocking conduit to transmit logs via DrainForever (or NonBlockingLogger).

func (*ChannelLogger) BufferCap

func (cl *ChannelLogger) BufferCap() channels.BufferCap

Get the cap off the internal ring buffer

func (*ChannelLogger) BufferLength

func (cl *ChannelLogger) BufferLength() int

Get the current occupancy level of the ring buffer

func (*ChannelLogger) DrainForever

func (cl *ChannelLogger) DrainForever(logger log.Logger)

Enters an infinite loop that will drain any log lines from the passed logger.

Exits if the channel is closed.

func (*ChannelLogger) Flush

func (cl *ChannelLogger) Flush(logger log.Logger)

Drains everything that is available at the time of calling

func (*ChannelLogger) FlushLogLines

func (cl *ChannelLogger) FlushLogLines() [][]interface{}

Drains the next contiguous segment of loglines up to the buffer cap waiting for at least one line

func (*ChannelLogger) Log

func (cl *ChannelLogger) Log(keyvals ...interface{}) error

func (*ChannelLogger) ReadLogLine

func (cl *ChannelLogger) ReadLogLine() []interface{}

Tries to read a log line from the channel buffer or returns nil if none is immediately available

func (*ChannelLogger) Reset

func (cl *ChannelLogger) Reset()

Close the existing channel halting goroutines that are draining the channel and create a new channel to buffer into. Should not cause any log lines arriving concurrently to be lost, but any that have not been drained from old channel may be.

func (*ChannelLogger) WaitReadLogLine

func (cl *ChannelLogger) WaitReadLogLine() []interface{}

Read a log line by waiting until one is available and returning it

type MultipleOutputLogger

type MultipleOutputLogger []log.Logger

This represents an 'AND' type logger. When logged to it will log to each of the loggers in the slice.

func (MultipleOutputLogger) Log

func (mol MultipleOutputLogger) Log(keyvals ...interface{}) error