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

View Source
const StackTraceBufferSize = 1024 * 100

Variables

This section is empty.

Functions

This section is empty.

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

      Directories

      Path Synopsis
      Package lagerctx provides convenience when using Lager with the context feature of the standard library.
      Package lagerctx provides convenience when using Lager with the context feature of the standard library.