lager

README

lager

Note: This repository should be imported as code.cloudfoundry.org/lager.

Lager is a logging library for go.

Usage

Instantiate a logger with the name of your component.

import (
  "code.cloudfoundry.org/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 JSONRedacter
  • func NewJSONRedacter(keyPatterns []string, valuePatterns []string) (*JSONRedacter, error)
  • func (r JSONRedacter) Redact(data []byte) []byte
• type LogFormat
  • func (log LogFormat) ToJSON() []byte
• type LogLevel
  • func LogLevelFromString(s string) (LogLevel, error)
  • func (l LogLevel) String() string
• 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(log LogFormat)
  • func (sink *ReconfigurableSink) SetMinLevel(level LogLevel)
• type Sink
  • func NewPrettySink(writer io.Writer, minLogLevel LogLevel) Sink
  • func NewRedactingSink(sink Sink, keyPatterns []string, valuePatterns []string) (Sink, error)
  • func NewWriterSink(writer io.Writer, minLogLevel LogLevel) Sink

Constants

const StackTraceBufferSize = 1024 * 100

Types

type Data

type Data map[string]interface{}

type JSONRedacter

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

func NewJSONRedacter

func NewJSONRedacter(keyPatterns []string, valuePatterns []string) (*JSONRedacter, error)

func (JSONRedacter) Redact

func (r JSONRedacter) Redact(data []byte) []byte

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"`
	Error     error    `json:"-"`
	// contains filtered or unexported fields
}

func (LogFormat) ToJSON

func (log LogFormat) ToJSON() []byte

type LogLevel

type LogLevel int

const (
	DEBUG LogLevel = iota
	INFO
	ERROR
	FATAL
)

func LogLevelFromString

func LogLevelFromString(s string) (LogLevel, error)

func (LogLevel) String

func (l LogLevel) String() string

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(log LogFormat)

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(LogFormat)
}

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

func NewPrettySink

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

func NewRedactingSink

func NewRedactingSink(sink Sink, keyPatterns []string, valuePatterns []string) (Sink, error)

NewRedactingSink creates a sink that redacts sensitive information from the data field. The old behavior of NewRedactingWriterSink (which was removed in v2) can be obtained using the following code:

redactingSink, err := NewRedactingSink(
	NewWriterSink(writer, minLogLevel),
	keyPatterns,
	valuePatterns,
)

if err != nil {
	return nil, err
}

return NewReconfigurableSink(
	redactingSink,
	minLogLevel,
), nil

func NewWriterSink

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