lager

README

lager

Lager is a logging library for go.

Usage

Instantiate a logger with the name of your component.

import (
  "github.com/pivotal-golang/lager"
)

logger := lager.NewLogger("my-app")

Sinks

Lager can write logs to a variety of destinations. You can specify the destinations using Lager sinks:

To write to an arbitrary Writer object:

logger.RegisterSink(lager.NewWriterSink(myWriter, lager.INFO))

Emitting logs

Lager supports the usual level-based logging, with an optional argument for arbitrary key-value data.

logger.Info("doing-stuff", lager.Data{
  "informative": true,
})

output:

{ "source": "my-app", "message": "doing-stuff", "data": { "informative": true }, "timestamp": 1232345, "log_level": 1 }

Error messages also take an Error object:

logger.Error("failed-to-do-stuff", errors.New("Something went wrong"))

output:

{ "source": "my-app", "message": "failed-to-do-stuff", "data": { "error": "Something went wrong" }, "timestamp": 1232345, "log_level": 1 }

Sessions

You can avoid repetition of contextual data using 'Sessions':

contextualLogger := logger.Session("my-task", lager.Data{
  "request-id": 5,
})

contextualLogger.Info("my-action")

output:

{ "source": "my-app", "message": "my-task.my-action", "data": { "request-id": 5 }, "timestamp": 1232345, "log_level": 1 }

License

Lager is Apache 2.0 licensed.

Documentation

Index

• Constants
• type Data
• type LogFormat
  • func (log LogFormat) ToJSON() []byte
• type LogLevel
• type Logger
  • func NewLogger(component string) Logger
• type ReconfigurableSink
  • func NewReconfigurableSink(sink Sink, initialMinLogLevel LogLevel) *ReconfigurableSink
  • func (sink *ReconfigurableSink) GetMinLevel() LogLevel
  • func (sink *ReconfigurableSink) Log(level LogLevel, log []byte)
  • func (sink *ReconfigurableSink) SetMinLevel(level LogLevel)
• type Sink
  • func NewWriterSink(writer io.Writer, minLogLevel LogLevel) Sink

Constants

const STACK_TRACE_BUFFER_SIZE = 1024 * 100

Types

type Data

type Data map[string]interface{}

type LogFormat

type LogFormat struct {
	Timestamp string   `json:"timestamp"`
	Source    string   `json:"source"`
	Message   string   `json:"message"`
	LogLevel  LogLevel `json:"log_level"`
	Data      Data     `json:"data"`
}

func (LogFormat) ToJSON

func (log LogFormat) ToJSON() []byte

type LogLevel

type LogLevel int

const (
	DEBUG LogLevel = iota
	INFO
	ERROR
	FATAL
)

type Logger

type Logger interface {
	RegisterSink(Sink)
	Session(task string, data ...Data) Logger
	SessionName() string
	Debug(action string, data ...Data)
	Info(action string, data ...Data)
	Error(action string, err error, data ...Data)
	Fatal(action string, err error, data ...Data)
	WithData(Data) Logger
}

func NewLogger

func NewLogger(component string) Logger

type ReconfigurableSink

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

func NewReconfigurableSink

func NewReconfigurableSink(sink Sink, initialMinLogLevel LogLevel) *ReconfigurableSink

func (*ReconfigurableSink) GetMinLevel

func (sink *ReconfigurableSink) GetMinLevel() LogLevel

func (*ReconfigurableSink) Log

func (sink *ReconfigurableSink) Log(level LogLevel, log []byte)

func (*ReconfigurableSink) SetMinLevel

func (sink *ReconfigurableSink) SetMinLevel(level LogLevel)

type Sink

type Sink interface {
	//Log to the sink.  Best effort -- no need to worry about errors.
	Log(level LogLevel, payload []byte)
}

A Sink represents a write destination for a Logger. It provides a thread-safe interface for writing logs

func NewWriterSink

func NewWriterSink(writer io.Writer, minLogLevel LogLevel) Sink