Documentation

Index

Constants

View Source
const (
	DefaultOptions opt = iota
	StringifyValues
)
View Source
const (
	JSONFormat     = "json"
	LogfmtFormat   = "logfmt"
	TerminalFormat = "terminal"
	DefaultFormat  = TerminalFormat
)
View Source
const (
	DefaultLoggingRingBufferCap channels.BufferCap = 100
)

Variables

This section is empty.

Functions

func FilterLogger

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

    Filter logger allows us to filter lines logged to it before passing on to underlying output logger Creates a logger that removes lines from output when the predicate evaluates true

    func NewBurrowFormatLogger

    func NewBurrowFormatLogger(logger log.Logger, options ...opt) *burrowFormatLogger

    func NewJSONLogger

    func NewJSONLogger(writer io.Writer) log.Logger

    func NewLogfmtLogger

    func NewLogfmtLogger(writer io.Writer) log.Logger

    func NewMultipleOutputLogger

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

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

      func NewStreamLogger

      func NewStreamLogger(writer io.Writer, format string) (log.Logger, error)

      func NewTemplateLogger

      func NewTemplateLogger(writer io.Writer, textTemplate string, recordSeparator []byte) (log.Logger, error)

      func NewTerminalLogger

      func NewTerminalLogger(writer io.Writer) log.Logger

      func SortLogger

      func SortLogger(outputLogger log.Logger, keys ...string) log.Logger

        Provides a logger that sorts key-values with keys in keys before other key-values

        func VectorValuedLogger

        func VectorValuedLogger(logger log.Logger) *vectorValuedLogger

        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 sent to it in a buffer retaining a reference to its output logger (the logger whose input it is capturing). It can optionally pass logs through 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 special circumstances.

          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() error

              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 NonBlockingLogger

                        func NonBlockingLogger(outputLogger log.Logger) (*ChannelLogger, channels.Channel)

                          Returns a Logger that wraps the outputLogger passed and does not block on calls to Log and a channel of any errors from the underlying logger

                          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, errCh channels.Channel)

                                Enters an infinite loop that will drain any log lines from the passed logger. You may pass in a channel

                                Exits if the channel is closed.

                                func (*ChannelLogger) Flush

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

                                  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 FileLogger

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

                                          func NewFileLogger

                                          func NewFileLogger(path string, formatName string) (*FileLogger, error)

                                          func (*FileLogger) Log

                                          func (fl *FileLogger) Log(keyvals ...interface{}) error

                                          func (*FileLogger) Reload

                                          func (fl *FileLogger) Reload() error

                                          type FileTemplateParams

                                          type FileTemplateParams struct {
                                          	Date time.Time
                                          }

                                          func NewFileTemplateParams

                                          func NewFileTemplateParams() *FileTemplateParams

                                          func (*FileTemplateParams) Timestamp

                                          func (ftp *FileTemplateParams) Timestamp() string

                                          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

                                            type Syncable

                                            type Syncable interface {
                                            	Sync() error
                                            }