lager

package
Version: v0.0.0-...-c919e4e Latest Latest
Warning

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

Go to latest
Published: Aug 22, 2016 License: Apache-2.0, MIT Imports: 7 Imported by: 0

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 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(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 NewWriterSink

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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL