lager

package module
v2.0.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 19, 2018 License: Apache-2.0 Imports: 10 Imported by: 1,210

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 added in v1.1.0

func LogLevelFromString(s string) (LogLevel, error)

func (LogLevel) String added in v1.1.0

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 added in v1.1.0

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL