logr

package module
v2.0.21 Latest Latest
Warning

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

 Go to latest Published: Nov 20, 2023 License: MIT Imports: 16 Imported by: 18

README

Logr_Logo

A fully asynchronous, contextual logger for Go.

logr

GoDoc Report Card

Logr is inspired by Logrus and Zap but addresses a number of issues:

  1. Logr is fully asynchronous, meaning that all formatting and writing is done in the background. Latency sensitive applications benefit from not waiting for logging to complete.

  2. Logr provides custom filters which provide more flexibility than Trace, Debug, Info... levels. If you need to temporarily increase verbosity of logging while tracking down a problem you can avoid the fire-hose that typically comes from Debug or Trace by using custom filters.

  3. Logr generates much less allocations than Logrus, and is close to Zap in allocations.

Concepts

entity description
Logr Engine instance typically instantiated once; used to configure logging.
lgr,_ := logr.New()
Logger Provides contextual logging via fields; lightweight, can be created once and accessed globally, or created on demand.
logger := lgr.NewLogger()
logger2 := logger.With(logr.String("user", "Sam"))
Target A destination for log items such as console, file, database or just about anything that can be written to. Each target has its own filter/level and formatter, and any number of targets can be added to a Logr. Targets for file, syslog and any io.Writer are built-in and it is easy to create your own. You can also use any Logrus hooks via a simple adapter.
Filter Determines which logging calls get written versus filtered out. Also determines which logging calls generate a stack trace.
filter := &logr.StdFilter{Lvl: logr.Warn, Stacktrace: logr.Fatal}
Formatter Formats the output. Logr includes built-in formatters for JSON and plain text with delimiters. It is easy to create your own formatters or you can also use any Logrus formatters via a simple adapter.
formatter := &format.Plain{Delim: " | "}

Usage

// Create Logr instance.
lgr,_ := logr.New()

// Create a filter and formatter. Both can be shared by multiple
// targets.
filter := &logr.StdFilter{Lvl: logr.Warn, Stacktrace: logr.Error}
formatter := &formatters.Plain{Delim: " | "}

// WriterTarget outputs to any io.Writer
t := targets.NewWriterTarget(filter, formatter, os.StdOut, 1000)
lgr.AddTarget(t)

// One or more Loggers can be created, shared, used concurrently,
// or created on demand.
logger := lgr.NewLogger().With("user", "Sarah")

// Now we can log to the target(s).
logger.Debug("login attempt")
logger.Error("login failed")

// Ensure targets are drained before application exit.
lgr.Shutdown()

Fields

Fields allow for contextual logging, meaning information can be added to log statements without changing the statements themselves. Information can be shared across multiple logging statements thus allowing log analysis tools to group them.

Fields can be added to a Logger via Logger.With or included with each log record:

lgr,_ := logr.New()
// ... add targets ...
logger := lgr.NewLogger().With(
    logr.Any("user": user), 
    logr.String("role", role)
)

logger.Info("login attempt", logr.Int("attempt_count", count))
// ... later ...
logger.Info("login", logr.String("result", result))

Logr fields are inspired by and work the same as Zap fields.

Filters

Logr supports the traditional seven log levels via logr.StdFilter: Panic, Fatal, Error, Warning, Info, Debug, and Trace.

// When added to a target, this filter will only allow
// log statements with level severity Warn or higher.
// It will also generate stack traces for Error or higher.
filter := &logr.StdFilter{Lvl: logr.Warn, Stacktrace: logr.Error}

Logr also supports custom filters (logr.CustomFilter) which allow fine grained inclusion of log items without turning on the fire-hose.

  // create custom levels; use IDs > 10.
  LoginLevel := logr.Level{ID: 100, Name: "login ", Stacktrace: false}
  LogoutLevel := logr.Level{ID: 101, Name: "logout", Stacktrace: false}

  lgr,_ := logr.New()

  // create a custom filter with custom levels.
  filter := &logr.CustomFilter{}
  filter.Add(LoginLevel, LogoutLevel)

  formatter := &formatters.Plain{Delim: " | "}
  tgr := targets.NewWriterTarget(filter, formatter, os.StdOut, 1000)
  lgr.AddTarget(tgr)
  logger := lgr.NewLogger().With(logr.String("user": "Bob"), logr.String("role": "admin"))

  logger.Log(LoginLevel, "this item will get logged")
  logger.Debug("won't be logged since Debug wasn't added to custom filter")

Both filter types allow you to determine which levels force a stack trace to be output. Note that generating stack traces cannot happen fully asynchronously and thus add some latency to the calling goroutine.

Targets

There are built-in targets for outputting to syslog, file, TCP, or any io.Writer. More will be added.

You can use any Logrus hooks via a simple adapter.

You can create your own target by implementing the simple Target interface.

Example target that outputs to io.Writer:

type Writer struct {
  out io.Writer
}

func NewWriterTarget(out io.Writer) *Writer {
  w := &Writer{out: out}
  return w
}

// Called once to initialize target.
func (w *Writer) Init() error {
  return nil
}

// Write will always be called by a single internal Logr goroutine, so no locking needed.
func (w *Writer) Write(p []byte, rec *logr.LogRec) (int, error) {
  return w.out.Write(buf.Bytes())
}

// Called once to cleanup/free resources for target.
func (w *Writer) Shutdown() error {
  return nil
}

Formatters

Logr has two built-in formatters, one for JSON and the other plain, delimited text.

You can use any Logrus formatters via a simple adapter.

You can create your own formatter by implementing the Formatter interface:

Format(rec *LogRec, stacktrace bool, buf *bytes.Buffer) (*bytes.Buffer, error)

Configuration options

When creating the Logr instance, you can set configuration options. For example:

lgr, err := logr.New(
    logr.MaxQueueSize(1000),
    logr.StackFilter("mypackage1", "mypackage2"),
)

Some options are documented below. See options.go for all available configuration options.

Logr.OnLoggerError(err error)

Called any time an internal logging error occurs. For example, this can happen when a target cannot connect to its data sink.

It may be tempting to log this error, however there is a danger that logging this will simply generate another error and so on. If you must log it, use a target and custom level specifically for this event and ensure it cannot generate more errors.

Logr.OnQueueFull func(rec *LogRec, maxQueueSize int) bool

Called on an attempt to add a log record to a full Logr queue. This generally means the Logr maximum queue size is too small, or at least one target is very slow. Logr maximum queue size can be changed before adding any targets via:

lgr, err := logr.New(logr.MaxQueueSize(2000))

Returning true will drop the log record. False will block until the log record can be added, which creates a natural throttle at the expense of latency for the calling goroutine. The default is to block.

Logr.OnTargetQueueFull func(target Target, rec *LogRec, maxQueueSize int) bool

Called on an attempt to add a log record to a full target queue. This generally means your target's max queue size is too small, or the target is very slow to output.

As with the Logr queue, returning true will drop the log record. False will block until the log record can be added, which creates a natural throttle at the expense of latency for the calling goroutine. The default is to block.

Logr.OnExit func(code int) and Logr.OnPanic func(err interface{})

OnExit and OnPanic are called when the Logger.FatalXXX and Logger.PanicXXX functions are called respectively.

In both cases the default behavior is to shut down gracefully, draining all targets, and calling os.Exit or panic respectively.

When adding your own handlers, be sure to call Logr.Shutdown before exiting the application to avoid losing log records.

Logr.StackFilter(pkg ...string)

StackFilter sets a list of package names to exclude from the top of stack traces. The Logr packages are automatically filtered.

Documentation

Index

Constants

View Source 
const (
	// DefaultMaxQueueSize is the default maximum queue size for Logr instances.
	DefaultMaxQueueSize = 1000

	// DefaultMaxStackFrames is the default maximum max number of stack frames collected
	// when generating stack traces for logging.
	DefaultMaxStackFrames = 30

	// MaxLevelID is the maximum value of a level ID. Some level cache implementations will
	// allocate a cache of this size. Cannot exceed uint.
	MaxLevelID = 65535

	// DefaultEnqueueTimeout is the default amount of time a log record can take to be queued.
	// This only applies to blocking enqueue which happen after `logr.OnQueueFull` is called
	// and returns false.
	DefaultEnqueueTimeout = time.Second * 30

	// DefaultShutdownTimeout is the default amount of time `logr.Shutdown` can execute before
	// timing out.
	DefaultShutdownTimeout = time.Second * 30

	// DefaultFlushTimeout is the default amount of time `logr.Flush` can execute before
	// timing out.
	DefaultFlushTimeout = time.Second * 30

	// DefaultMaxPooledBuffer is the maximum size a pooled buffer can be.
	// Buffers that grow beyond this size are garbage collected.
	DefaultMaxPooledBuffer = 1024 * 1024

	// DefaultMaxFieldLength is the maximum size of a String or fmt.Stringer field can be.
	DefaultMaxFieldLength = -1
)

Defaults.

View Source 
const (
	// DefTimestampFormat is the default time stamp format used by Plain formatter and others.
	DefTimestampFormat = "2006-01-02 15:04:05.000 Z07:00"

	// TimestampMillisFormat is the format for logging milliseconds UTC
	TimestampMillisFormat = "Jan _2 15:04:05.000"
)
View Source 
const (
	DefMetricsUpdateFreqMillis = 15000 // 15 seconds
)

Variables

View Source 
var (
	Comma   = []byte{','}
	Equals  = []byte{'='}
	Space   = []byte{' '}
	Newline = []byte{'\n'}
	Quote   = []byte{'"'}
	Colon   = []byte{':'}
)
View Source 
var (
	// Panic is the highest level of severity.
	Panic = Level{ID: 0, Name: "panic", Color: Red}
	// Fatal designates a catastrophic error.
	Fatal = Level{ID: 1, Name: "fatal", Color: Red}
	// Error designates a serious but possibly recoverable error.
	Error = Level{ID: 2, Name: "error", Color: Red}
	// Warn designates non-critical error.
	Warn = Level{ID: 3, Name: "warn", Color: Yellow}
	// Info designates information regarding application events.
	Info = Level{ID: 4, Name: "info", Color: Cyan}
	// Debug designates verbose information typically used for debugging.
	Debug = Level{ID: 5, Name: "debug", Color: NoColor}
	// Trace designates the highest verbosity of log output.
	Trace = Level{ID: 6, Name: "trace", Color: NoColor}
)
View Source 
var AnsiColorPrefix = []byte("\u001b[")
View Source 
var AnsiColorSuffix = []byte("m")

Functions

func GetLogrPackageName added in v2.0.10 

func GetLogrPackageName() string

GetPackageName returns the root package name of Logr.

func GetPackageName added in v2.0.3 

func GetPackageName(callingFuncName string) string

GetPackageName returns the package name of the caller. `callingFuncName` should be the name of the calling function and should be unique enough not to collide with any runtime methods.

func IsTimeoutError 

func IsTimeoutError(err error) bool

IsTimeoutError returns true if err is a TimeoutError.

func LimitByteSlice added in v2.0.17 

func LimitByteSlice(b []byte, limit int) []byte

LimitByteSlice discards the bytes from a slice that exceeds the limit

func LimitString added in v2.0.17 

func LimitString(b string, limit int) string

LimitString discards the runes from a slice that exceeds the limit

func NewStdLogger 

func NewStdLogger(level Level, logger Logger) *log.Logger

NewStdLogger creates a standard logger backed by a Logr instance. All log records are emitted with the specified log level.

func ResolvePackageName added in v2.0.10 

func ResolvePackageName(f string) string

ResolvePackageName reduces a fully qualified function name to the package name

func WriteFields 

func WriteFields(w io.Writer, fields []Field, separator []byte, color Color) error

WriteFields writes zero or more name value pairs to the io.Writer. The pairs output in key=value format with optional separator between fields.

func WriteStacktrace 

func WriteStacktrace(w io.Writer, frames []runtime.Frame) error

WriteStacktrace formats and outputs a stack trace to an io.Writer.

func WriteWithColor 

func WriteWithColor(w io.Writer, s string, color Color) error

WriteWithColor outputs a string with the specified ANSI color.

Types

type Buffer added in v2.0.11 

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

Buffer provides a thread-safe buffer useful for logging to memory in unit tests.

func (*Buffer) Read added in v2.0.11 

func (b *Buffer) Read(p []byte) (n int, err error)

func (*Buffer) String added in v2.0.11 

func (b *Buffer) String() string

func (*Buffer) Write added in v2.0.11 

func (b *Buffer) Write(p []byte) (n int, err error)

type Color 

type Color uint8

Color for formatters that support color output. 

const (
	NoColor Color = 0
	Red     Color = 31
	Green   Color = 32
	Yellow  Color = 33
	Blue    Color = 34
	Magenta Color = 35
	Cyan    Color = 36
	White   Color = 37
)

type Counter 

type Counter interface {
	// Inc increments the counter by 1. Use Add to increment it by arbitrary non-negative values.
	Inc()
	// Add adds the given value to the counter. It panics if the value is < 0.
	Add(float64)
}

Counter is a simple metrics sink that can only increment a value. Implementations are external to Logr and provided via `MetricsCollector`.

type CustomFilter 

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

CustomFilter allows targets to enable logging via a list of discrete levels.

func NewCustomFilter 

func NewCustomFilter(levels ...Level) *CustomFilter

NewCustomFilter creates a filter supporting discrete log levels.

func (*CustomFilter) Add 

func (cf *CustomFilter) Add(levels ...Level)

Add adds one or more levels to the list. Adding a level enables logging for that level on any targets using this CustomFilter.

func (*CustomFilter) GetEnabledLevel 

func (cf *CustomFilter) GetEnabledLevel(level Level) (Level, bool)

GetEnabledLevel returns the Level with the specified Level.ID and whether the level is enabled for this filter.

type DefaultFormatter 

type DefaultFormatter struct {
}

DefaultFormatter is the default formatter, outputting only text with no colors and a space delimiter. Use `format.Plain` instead.

func (*DefaultFormatter) Format 

func (p *DefaultFormatter) Format(rec *LogRec, level Level, buf *bytes.Buffer) (*bytes.Buffer, error)

Format converts a log record to bytes.

func (*DefaultFormatter) IsStacktraceNeeded added in v2.0.3 

func (p *DefaultFormatter) IsStacktraceNeeded() bool

IsStacktraceNeeded always returns false for default formatter since the `Caller` field is not supported.

type Field 

type Field struct {
	Key       string
	Type      FieldType
	Integer   int64
	Float     float64
	String    string
	Interface interface{}
}

func Any 

func Any(key string, val any) Field

Any picks the best supported field type based on type of val. For best performance when passing a struct (or struct pointer), implement `logr.LogWriter` on the struct, otherwise reflection will be used to generate a string representation.

func Array 

func Array[S ~[]E, E any](key string, val S) Field

Array constructs a field containing a key and array value.

func Bool 

func Bool[T ~bool](key string, val T) Field

Bool constructs a field containing a key and bool value.

func Duration 

func Duration(key string, val time.Duration) Field

Duration constructs a field containing a key and time.Duration value.

func Err 

func Err(err error) Field

Err constructs a field containing a default key ("error") and error value.

func Float added in v2.0.19 

func Float[T ~float32 | ~float64](key string, val T) Field

Float32 constructs a field containing a key and float value.

func Float32 deprecated 

func Float32(key string, val float32) Field

Float32 constructs a field containing a key and Float32 value.

Deprecated: Use logr.Float instead

func Float64 deprecated 

func Float64(key string, val float64) Field

Float64 constructs a field containing a key and Float64 value.

Deprecated: Use logr.Float instead

func Int 

func Int[T ~int | ~int8 | ~int16 | ~int32 | ~int64](key string, val T) Field

Int constructs a field containing a key and int value.

func Int32 deprecated 

func Int32(key string, val int32) Field

Int32 constructs a field containing a key and Int32 value.

Deprecated: Use logr.Int instead.

func Int64 deprecated 

func Int64(key string, val int64) Field

Int64 constructs a field containing a key and Int64 value.

Deprecated: Use logr.Int instead.

func Map 

func Map[M ~map[K]V, K comparable, V any](key string, val M) Field

Map constructs a field containing a key and map value.

func Millis 

func Millis(key string, val int64) Field

Millis constructs a field containing a key and timestamp value. The timestamp is expected to be milliseconds since Jan 1, 1970 UTC.

func NamedErr 

func NamedErr(key string, err error) Field

NamedErr constructs a field containing a key and error value.

func String 

func String[T ~string | ~[]byte](key string, val T) Field

String constructs a field containing a key and String value.

func Stringer 

func Stringer(key string, val fmt.Stringer) Field

Stringer constructs a field containing a key and a `fmt.Stringer` value. The `String` method will be called in lazy fashion.

func Time 

func Time(key string, val time.Time) Field

Time constructs a field containing a key and time.Time value.

func Uint 

func Uint[T ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr](key string, val T) Field

Uint constructs a field containing a key and uint value.

func Uint32 deprecated 

func Uint32(key string, val uint32) Field

Uint32 constructs a field containing a key and Uint32 value.

Deprecated: Use logr.Uint instead

func Uint64 deprecated 

func Uint64(key string, val uint64) Field

Uint64 constructs a field containing a key and Uint64 value.

Deprecated: Use logr.Uint instead.

func (Field) ValueString 

func (f Field) ValueString(w io.Writer, shouldQuote func(s string) bool) error

ValueString converts a known type to a string using default formatting. This is called lazily by a formatter. Formatters can provide custom formatting or types passed via `Any` can implement the `LogString` interface to generate output for logging. If the optional shouldQuote callback is provided, then it will be called for any string output that could potentially need to be quoted.

type FieldSorter 

type FieldSorter []Field

FieldSorter provides sorting of an array of fields by key.

func (FieldSorter) Len 

func (fs FieldSorter) Len() int

func (FieldSorter) Less 

func (fs FieldSorter) Less(i, j int) bool

func (FieldSorter) Swap 

func (fs FieldSorter) Swap(i, j int)

type FieldType 

type FieldType uint8
const (
	UnknownType FieldType = iota
	StringType
	StringerType
	StructType
	ErrorType
	BoolType
	TimestampMillisType
	TimeType
	DurationType
	Int64Type
	Int32Type
	IntType
	Uint64Type
	Uint32Type
	UintType
	Float64Type
	Float32Type
	BinaryType
	ArrayType
	MapType
)

type Filter 

type Filter interface {
	GetEnabledLevel(level Level) (Level, bool)
}

Filter allows targets to determine which Level(s) are active for logging and which Level(s) require a stack trace to be output. A default implementation using "panic, fatal..." is provided, and a more flexible alternative implementation is also provided that allows any number of custom levels.

type Formatter 

type Formatter interface {
	// IsStacktraceNeeded returns true if this formatter requires a stacktrace to be
	// generated for each LogRecord. Enabling features such as `Caller` field require
	// a stacktrace.
	IsStacktraceNeeded() bool

	// Format converts a log record to bytes. If buf is not nil then it will be
	// be filled with the formatted results, otherwise a new buffer will be allocated.
	Format(rec *LogRec, level Level, buf *bytes.Buffer) (*bytes.Buffer, error)
}

Formatter turns a LogRec into a formatted string.

type Gauge 

type Gauge interface {
	// Set sets the Gauge to an arbitrary value.
	Set(float64)
	// Add adds the given value to the Gauge. (The value can be negative, resulting in a decrease of the Gauge.)
	Add(float64)
	// Sub subtracts the given value from the Gauge. (The value can be negative, resulting in an increase of the Gauge.)
	Sub(float64)
}

Gauge is a simple metrics sink that can receive values and increase or decrease. Implementations are external to Logr and provided via `MetricsCollector`.

type Level 

type Level struct {
	ID         LevelID `json:"id"`
	Name       string  `json:"name"`
	Stacktrace bool    `json:"stacktrace,omitempty"`
	Color      Color   `json:"color,omitempty"`
}

Level provides a mechanism to enable/disable specific log lines.

func (Level) String 

func (level Level) String() string

String returns the name of this level.

type LevelID 

type LevelID uint

LevelID is the unique id of each level.

type LevelStatus 

type LevelStatus struct {
	Enabled    bool
	Stacktrace bool
	// contains filtered or unexported fields
}

LevelStatus represents whether a level is enabled and requires a stack trace.

type LimitedStringer added in v2.0.17 

type LimitedStringer struct {
	fmt.Stringer
	Limit int
}

func (*LimitedStringer) String added in v2.0.17 

func (ls *LimitedStringer) String() string

type LogCloner 

type LogCloner interface {
	LogClone() interface{}
}

LogCloner is implemented by `Any` types that require a clone to be provided to the logger because the original may mutate.

type LogRec 

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

LogRec collects raw, unformatted data to be logged. TODO: pool these? how to reliably know when targets are done with them? Copy for each target?

func NewLogRec 

func NewLogRec(lvl Level, logger Logger, msg string, fields []Field, incStacktrace bool) *LogRec

NewLogRec creates a new LogRec with the current time and optional stack trace.

func (*LogRec) Caller added in v2.0.3 

func (rec *LogRec) Caller() string

Caller returns this log record's caller info, meaning the file and line number where this log record was emitted. Returns empty string if no stack trace was provided.

func (*LogRec) Fields 

func (rec *LogRec) Fields() []Field

Fields returns this log record's Fields.

func (*LogRec) Level 

func (rec *LogRec) Level() Level

Level returns this log record's Level.

func (*LogRec) Logger 

func (rec *LogRec) Logger() Logger

Logger returns the `Logger` that created this `LogRec`.

func (*LogRec) Msg 

func (rec *LogRec) Msg() string

Msg returns this log record's message text.

func (*LogRec) StackFrames 

func (rec *LogRec) StackFrames() []runtime.Frame

StackFrames returns this log record's stack frames or nil if no stack trace was required.

func (*LogRec) String 

func (rec *LogRec) String() string

String returns a string representation of this log record.

func (*LogRec) Time 

func (rec *LogRec) Time() time.Time

Time returns this log record's time stamp.

func (*LogRec) WithTime 

func (rec *LogRec) WithTime(time time.Time) *LogRec

WithTime returns a shallow copy of the log record while replacing the time. This can be used by targets and formatters to adjust the time, or take ownership of the log record.

type LogWriter 

type LogWriter interface {
	LogWrite(w io.Writer) error
}

LogWriter is implemented by `Any` types that provide custom formatting for log output. A string representation of the type should be written directly to the `io.Writer`.

type Logger 

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

Logger provides context for logging via fields.

func (Logger) Debug 

func (logger Logger) Debug(msg string, fields ...Field)

Debug is a convenience method equivalent to `Log(DebugLevel, msg, fields...)`.

func (Logger) Error 

func (logger Logger) Error(msg string, fields ...Field)

Error is a convenience method equivalent to `Log(ErrorLevel, msg, fields...)`.

func (Logger) Fatal 

func (logger Logger) Fatal(msg string, fields ...Field)

Fatal is a convenience method equivalent to `Log(FatalLevel, msg, fields...)`

func (Logger) Info 

func (logger Logger) Info(msg string, fields ...Field)

Info is a convenience method equivalent to `Log(InfoLevel, msg, fields...)`.

func (Logger) IsLevelEnabled 

func (logger Logger) IsLevelEnabled(level Level) bool

IsLevelEnabled determines if the specified level is enabled for at least one log target.

func (Logger) Log 

func (logger Logger) Log(lvl Level, msg string, fields ...Field)

Log checks that the level matches one or more targets, and if so, generates a log record that is added to the Logr queue. Arguments are handled in the manner of fmt.Print.

func (Logger) LogM 

func (logger Logger) LogM(levels []Level, msg string, fields ...Field)

LogM calls `Log` multiple times, one for each level provided.

func (Logger) Logr 

func (logger Logger) Logr() *Logr

Logr returns the `Logr` instance that created this `Logger`.

func (Logger) Panic 

func (logger Logger) Panic(msg string, fields ...Field)

Panic is a convenience method equivalent to `Log(PanicLevel, msg, fields...)`

func (Logger) StdLogger 

func (logger Logger) StdLogger(level Level) *log.Logger

StdLogger creates a standard logger backed by this `Logr.Logger` instance. All log records are emitted with the specified log level.

func (Logger) Sugar 

func (logger Logger) Sugar(fields ...Field) Sugar

Sugar creates a new `Logger` with a less structured API. Any fields are preserved.

func (Logger) Trace 

func (logger Logger) Trace(msg string, fields ...Field)

Trace is a convenience method equivalent to `Log(TraceLevel, msg, fields...)`.

func (Logger) Warn 

func (logger Logger) Warn(msg string, fields ...Field)

Warn is a convenience method equivalent to `Log(WarnLevel, msg, fields...)`.

func (Logger) With 

func (logger Logger) With(fields ...Field) Logger

With creates a new `Logger` with any existing fields plus the new ones.

type Logr 

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

Logr maintains a list of log targets and accepts incoming log records. Use `New` to create instances.

func New 

func New(opts ...Option) (*Logr, error)

New creates a new Logr instance with one or more options specified. Some options with invalid values can cause an error to be returned, however `logr.New()` using just defaults never errors.

func (*Logr) AddTarget 

func (lgr *Logr) AddTarget(target Target, name string, filter Filter, formatter Formatter, maxQueueSize int) error

AddTarget adds a target to the logger which will receive log records for outputting.

func (*Logr) BorrowBuffer 

func (lgr *Logr) BorrowBuffer() *bytes.Buffer

BorrowBuffer borrows a buffer from the pool. Release the buffer to reduce garbage collection.

func (*Logr) Flush 

func (lgr *Logr) Flush() error

Flush blocks while flushing the logr queue and all target queues, by writing existing log records to valid targets. Any attempts to add new log records will block until flush is complete. `logr.FlushTimeout` determines how long flush can execute before timing out. Use `IsTimeoutError` to determine if the returned error is due to a timeout.

func (*Logr) FlushWithTimeout 

func (lgr *Logr) FlushWithTimeout(ctx context.Context) error

Flush blocks while flushing the logr queue and all target queues, by writing existing log records to valid targets. Any attempts to add new log records will block until flush is complete. Use `IsTimeoutError` to determine if the returned error is due to a timeout.

func (*Logr) HasTargets 

func (lgr *Logr) HasTargets() bool

HasTargets returns true only if at least one target exists within the lgr.

func (*Logr) IsLevelEnabled 

func (lgr *Logr) IsLevelEnabled(lvl Level) LevelStatus

IsLevelEnabled returns true if at least one target has the specified level enabled. The result is cached so that subsequent checks are fast.

func (*Logr) IsShutdown 

func (lgr *Logr) IsShutdown() bool

IsShutdown returns true if this Logr instance has been shut down. No further log records can be enqueued and no targets added after shutdown.

func (*Logr) NewLogger 

func (lgr *Logr) NewLogger() Logger

NewLogger creates a Logger using defaults. A `Logger` is light-weight enough to create on-demand, but typically one or more Loggers are created and re-used.

func (*Logr) RedirectStdLog 

func (lgr *Logr) RedirectStdLog(level Level, fields ...Field) func()

RedirectStdLog redirects output from the standard library's package-global logger to this logger at the specified level and with zero or more Field's. Since Logr already handles caller annotations, timestamps, etc., it automatically disables the standard library's annotations and prefixing. A function is returned that restores the original prefix and flags and resets the standard library's output to os.Stderr.

func (*Logr) ReleaseBuffer 

func (lgr *Logr) ReleaseBuffer(buf *bytes.Buffer)

ReleaseBuffer returns a buffer to the pool to reduce garbage collection. The buffer is only retained if less than MaxPooledBuffer.

func (*Logr) RemoveTargets 

func (lgr *Logr) RemoveTargets(cxt context.Context, f func(ti TargetInfo) bool) error

RemoveTargets safely removes one or more targets based on the filtering method. f should return true to delete the target, false to keep it. When removing a target, best effort is made to write any queued log records before closing, with cxt determining how much time can be spent in total. Note, keep the timeout short since this method blocks certain logging operations.

func (*Logr) ReportError 

func (lgr *Logr) ReportError(err interface{})

ReportError is used to notify the host application of any internal logging errors. If `OnLoggerError` is not nil, it is called with the error, otherwise the error is output to `os.Stderr`.

func (*Logr) ResetLevelCache 

func (lgr *Logr) ResetLevelCache()

ResetLevelCache resets the cached results of `IsLevelEnabled`. This is called any time a Target is added or a target's level is changed.

func (*Logr) SetMetricsCollector added in v2.0.10 

func (lgr *Logr) SetMetricsCollector(collector MetricsCollector, updateFreqMillis int64)

SetMetricsCollector sets (or resets) the metrics collector to be used for gathering metrics for all targets. Only targets added after this call will use the collector.

To ensure all targets use a collector, use the `SetMetricsCollector` option when creating the Logr instead, or configure/reconfigure the Logr after calling this method.

func (*Logr) Shutdown 

func (lgr *Logr) Shutdown() error

Shutdown cleanly stops the logging engine after making best efforts to flush all targets. Call this function right before application exit - logr cannot be restarted once shut down. `logr.ShutdownTimeout` determines how long shutdown can execute before timing out. Use `IsTimeoutError` to determine if the returned error is due to a timeout.

func (*Logr) ShutdownWithTimeout 

func (lgr *Logr) ShutdownWithTimeout(ctx context.Context) error

Shutdown cleanly stops the logging engine after making best efforts to flush all targets. Call this function right before application exit - logr cannot be restarted once shut down. Use `IsTimeoutError` to determine if the returned error is due to a timeout.

func (*Logr) TargetInfos 

func (lgr *Logr) TargetInfos() []TargetInfo

TargetInfos enumerates all the targets added to this lgr. The resulting slice represents a snapshot at time of calling.

type MetricsCollector 

type MetricsCollector interface {
	// QueueSizeGauge returns a Gauge that will be updated by the named target.
	QueueSizeGauge(target string) (Gauge, error)
	// LoggedCounter returns a Counter that will be incremented by the named target.
	LoggedCounter(target string) (Counter, error)
	// ErrorCounter returns a Counter that will be incremented by the named target.
	ErrorCounter(target string) (Counter, error)
	// DroppedCounter returns a Counter that will be incremented by the named target.
	DroppedCounter(target string) (Counter, error)
	// BlockedCounter returns a Counter that will be incremented by the named target.
	BlockedCounter(target string) (Counter, error)
}

MetricsCollector provides a way for users of this Logr package to have metrics pushed in an efficient way to any backend, e.g. Prometheus. For each target added to Logr, the supplied MetricsCollector will provide a Gauge and Counters that will be called frequently as logging occurs.

type Option 

type Option func(*Logr) error

func DisableBufferPool 

func DisableBufferPool(disable bool) Option

DisableBufferPool when true disables the buffer pool. See MaxPooledBuffer.

func EnqueueTimeout 

func EnqueueTimeout(dur time.Duration) Option

EnqueueTimeout is the amount of time a log record can take to be queued. This only applies to blocking enqueue which happen after `logr.OnQueueFull` is called and returns false.

func FlushTimeout 

func FlushTimeout(dur time.Duration) Option

FlushTimeout is the amount of time `logr.Flush` can execute before timing out. An alternative is to use `logr.FlushWithContext` and supply a timeout.

func MaxFieldLen added in v2.0.17 

func MaxFieldLen(size int) Option

MaxFieldLen is the maximum number of characters for a field. If exceeded, remaining bytes will be discarded. Defaults to DefaultMaxFieldLength.

func MaxPooledBufferSize 

func MaxPooledBufferSize(size int) Option

MaxPooledBufferSize determines the maximum size of a buffer that can be pooled. To reduce allocations, the buffers needed during formatting (etc) are pooled. A very large log item will grow a buffer that could stay in memory indefinitely. This setting lets you control how big a pooled buffer can be - anything larger will be garbage collected after use. Defaults to 1MB.

func MaxQueueSize 

func MaxQueueSize(size int) Option

MaxQueueSize is the maximum number of log records that can be queued. If exceeded, `OnQueueFull` is called which determines if the log record will be dropped or block until add is successful. Defaults to DefaultMaxQueueSize.

func OnExit 

func OnExit(f func(code int)) Option

OnExit, when not nil, is called when a FatalXXX style log API is called. When nil, the default behavior is to cleanly shut down this Logr and call `os.Exit(code)`.

func OnLoggerError 

func OnLoggerError(f func(error)) Option

OnLoggerError, when not nil, is called any time an internal logging error occurs. For example, this can happen when a target cannot connect to its data sink.

func OnPanic 

func OnPanic(f func(err interface{})) Option

OnPanic, when not nil, is called when a PanicXXX style log API is called. When nil, the default behavior is to cleanly shut down this Logr and call `panic(err)`.

func OnQueueFull 

func OnQueueFull(f func(rec *LogRec, maxQueueSize int) bool) Option

OnQueueFull, when not nil, is called on an attempt to add a log record to a full Logr queue. `MaxQueueSize` can be used to modify the maximum queue size. This function should return quickly, with a bool indicating whether the log record should be dropped (true) or block until the log record is successfully added (false). If nil then blocking (false) is assumed.

func OnTargetQueueFull 

func OnTargetQueueFull(f func(target Target, rec *LogRec, maxQueueSize int) bool) Option

OnTargetQueueFull, when not nil, is called on an attempt to add a log record to a full target queue provided the target supports reporting this condition. This function should return quickly, with a bool indicating whether the log record should be dropped (true) or block until the log record is successfully added (false). If nil then blocking (false) is assumed.

func SetMetricsCollector 

func SetMetricsCollector(collector MetricsCollector, updateFreqMillis int64) Option

SetMetricsCollector enables metrics collection by supplying a MetricsCollector. The MetricsCollector provides counters and gauges that are updated by log targets. `updateFreqMillis` determines how often polled metrics are updated. Defaults to 15000 (15 seconds) and must be at least 250 so we don't peg the CPU.

func ShutdownTimeout 

func ShutdownTimeout(dur time.Duration) Option

ShutdownTimeout is the amount of time `logr.Shutdown` can execute before timing out. An alternative is to use `logr.ShutdownWithContext` and supply a timeout.

func StackFilter 

func StackFilter(pkg ...string) Option

StackFilter provides a list of package names to exclude from the top of stack traces. The Logr packages are automatically filtered.

func UseSyncMapLevelCache 

func UseSyncMapLevelCache(use bool) Option

UseSyncMapLevelCache can be set to true when high concurrency (e.g. >32 cores) is expected. This may improve performance with large numbers of cores - benchmark for your use case.

type StdFilter 

type StdFilter struct {
	Lvl        Level
	Stacktrace Level
}

StdFilter allows targets to filter via classic log levels where any level beyond a certain verbosity/severity is enabled.

func (StdFilter) GetEnabledLevel 

func (lt StdFilter) GetEnabledLevel(level Level) (Level, bool)

GetEnabledLevel returns the Level with the specified Level.ID and whether the level is enabled for this filter.

func (StdFilter) IsEnabled 

func (lt StdFilter) IsEnabled(level Level) bool

IsEnabled returns true if the specified Level is at or above this verbosity. Also determines if a stack trace is required.

func (StdFilter) IsStacktraceEnabled 

func (lt StdFilter) IsStacktraceEnabled(level Level) bool

IsStacktraceEnabled returns true if the specified Level requires a stack trace.

type Sugar 

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

Sugar provides a less structured API for logging.

func (Sugar) Debug 

func (s Sugar) Debug(msg string, args ...interface{})

Debug is a convenience method equivalent to `Log(DebugLevel, msg, args...)`.

func (Sugar) Debugf 

func (s Sugar) Debugf(format string, args ...interface{})

Debugf is a convenience method equivalent to `Logf(DebugLevel, args...)`.

func (Sugar) Debugw added in v2.0.12 

func (s Sugar) Debugw(msg string, keyValuePairs ...interface{})

Debugw outputs at debug level with the specified key/value pairs converted to fields.

func (Sugar) Error 

func (s Sugar) Error(msg string, args ...interface{})

Error is a convenience method equivalent to `Log(ErrorLevel, msg, args...)`.

func (Sugar) Errorf 

func (s Sugar) Errorf(format string, args ...interface{})

Errorf is a convenience method equivalent to `Logf(ErrorLevel, args...)`.

func (Sugar) Errorw added in v2.0.12 

func (s Sugar) Errorw(msg string, keyValuePairs ...interface{})

Errorw outputs at error level with the specified key/value pairs converted to fields.

func (Sugar) Fatal 

func (s Sugar) Fatal(msg string, args ...interface{})

Fatal is a convenience method equivalent to `Log(FatalLevel, msg, args...)`

func (Sugar) Fatalf 

func (s Sugar) Fatalf(format string, args ...interface{})

Fatalf is a convenience method equivalent to `Logf(FatalLevel, args...)`

func (Sugar) Fatalw added in v2.0.12 

func (s Sugar) Fatalw(msg string, keyValuePairs ...interface{})

Fatalw outputs at fatal level with the specified key/value pairs converted to fields.

func (Sugar) Info 

func (s Sugar) Info(msg string, args ...interface{})

Info is a convenience method equivalent to `Log(InfoLevel, msg, args...)`.

func (Sugar) Infof 

func (s Sugar) Infof(format string, args ...interface{})

Infof is a convenience method equivalent to `Logf(InfoLevel, args...)`.

func (Sugar) Infow added in v2.0.12 

func (s Sugar) Infow(msg string, keyValuePairs ...interface{})

Infow outputs at info level with the specified key/value pairs converted to fields.

func (Sugar) Logf 

func (s Sugar) Logf(lvl Level, format string, args ...interface{})

Logf checks that the level matches one or more targets, and if so, generates a log record that is added to the main queue (channel). Arguments are handled in the manner of fmt.Printf.

func (Sugar) Panic 

func (s Sugar) Panic(msg string, args ...interface{})

Panic is a convenience method equivalent to `Log(PanicLevel, msg, args...)`

func (Sugar) Panicf 

func (s Sugar) Panicf(format string, args ...interface{})

Panicf is a convenience method equivalent to `Logf(PanicLevel, args...)`

func (Sugar) Panicw added in v2.0.12 

func (s Sugar) Panicw(msg string, keyValuePairs ...interface{})

Panicw outputs at panic level with the specified key/value pairs converted to fields.

func (Sugar) Print 

func (s Sugar) Print(msg string, args ...interface{})

Print ensures compatibility with std lib logger.

func (Sugar) Printf 

func (s Sugar) Printf(format string, args ...interface{})

Printf ensures compatibility with std lib logger.

func (Sugar) Trace 

func (s Sugar) Trace(msg string, args ...interface{})

Trace is a convenience method equivalent to `Log(TraceLevel, msg, args...)`.

func (Sugar) Tracef 

func (s Sugar) Tracef(format string, args ...interface{})

Tracef is a convenience method equivalent to `Logf(TraceLevel, args...)`.

func (Sugar) Tracew added in v2.0.12 

func (s Sugar) Tracew(msg string, keyValuePairs ...interface{})

Tracew outputs at trace level with the specified key/value pairs converted to fields.

func (Sugar) Warn 

func (s Sugar) Warn(msg string, args ...interface{})

Warn is a convenience method equivalent to `Log(WarnLevel, msg, args...)`.

func (Sugar) Warnf 

func (s Sugar) Warnf(format string, args ...interface{})

Warnf is a convenience method equivalent to `Logf(WarnLevel, args...)`.

func (Sugar) Warnw added in v2.0.12 

func (s Sugar) Warnw(msg string, keyValuePairs ...interface{})

Warnw outputs at warn level with the specified key/value pairs converted to fields.

func (Sugar) With added in v2.0.12 

func (s Sugar) With(keyValuePairs ...interface{}) Sugar

With returns a new Sugar logger with the specified key/value pairs added to the fields list.

type Target 

type Target interface {
	// Init is called once to initialize the target.
	Init() error

	// Write outputs to this target's destination.
	Write(p []byte, rec *LogRec) (int, error)

	// Shutdown is called once to free/close any resources.
	// Target queue is already drained when this is called.
	Shutdown() error
}

Target represents a destination for log records such as file, database, TCP socket, etc.

type TargetHost 

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

TargetHost hosts and manages the lifecycle of a target. Incoming log records are queued and formatted before being passed to the target.

func (*TargetHost) IsLevelEnabled 

func (h *TargetHost) IsLevelEnabled(lvl Level) (enabled bool, level Level)

IsLevelEnabled returns true if this target should emit logs for the specified level.

func (*TargetHost) Log 

func (h *TargetHost) Log(rec *LogRec)

Log queues a log record to be output to this target's destination.

func (*TargetHost) Shutdown 

func (h *TargetHost) Shutdown(ctx context.Context) error

Shutdown stops processing log records after making best effort to flush queue.

func (*TargetHost) String 

func (h *TargetHost) String() string

String returns a name for this target.

type TargetInfo 

type TargetInfo struct {
	Name string
	Type string
}

TargetInfo provides name and type for a Target.

type TargetWithMetrics 

type TargetWithMetrics interface {
	EnableMetrics(collector MetricsCollector, updateFreqMillis int64) error
}

TargetWithMetrics is a target that provides metrics.

type Writer 

type Writer struct {
	io.Writer
}

func (Writer) Writes 

func (w Writer) Writes(elems ...[]byte) (int, error)

Source Files

View all Source files

Directories

Path Synopsis
cmd/gelf
cmd/metrics
cmd/simple
cmd/testapp1

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.