README
¶
This is a fork of the exellent Apex Log library.
Main changes:
- Trim unneeded dependencies.
- Make
Fieldsinto a slice to preserve log order. - Split the old
Interfacein two and remove all but oneLogmethod (see below). - This allows for lazy creation of messages in
Log(fmt.Stringer)and ignoring fields added inLevelLoggers with levels below theLoggers. - The pointer passed to
HandleLogis not safe to use outside of that method, need to be cloned withClonefirst if that's needed.
// Logger is the main interface for the logger.
type Logger interface {
// WithLevel returns a new entry with `level` set.
WithLevel(Level) *EntryFields
}
// LevelLogger handles logging for a given level.
type LevelLogger interface {
// Log logs a message at the given level using the string from calling s.String().
// Note that s.String() will not be called if the level is not enabled.
Log(s fmt.Stringer)
// WithLevel returns a new entry with `level` set.
WithLevel(Level) *EntryFields
// WithFields returns a new entry with the`fields` in fields set.
// This is a noop if LevelLogger's level is less than Logger's.
WithFields(fields Fielder) *EntryFields
// WithLevel returns a new entry with the field f set with value v
// This is a noop if LevelLogger's level is less than Logger's.
WithField(f string, v any) *EntryFields
// WithDuration returns a new entry with the "duration" field set
// to the given duration in milliseconds.
// This is a noop if LevelLogger's level is less than Logger's.
WithDuration(time.Duration) *EntryFields
// WithError returns a new entry with the "error" set to `err`.
// This is a noop if err is nil or LevelLogger's level is less than Logger's.
WithError(error) *EntryFields
}
Documentation
¶
Overview ¶
Package log implements a simple structured logging API.
Index ¶
- Variables
- type Clock
- type Entry
- func (e *Entry) Clone() *Entry
- func (e *Entry) Log(s fmt.Stringer)
- func (e *Entry) WithDuration(d time.Duration) *Entry
- func (e *Entry) WithError(err error) *Entry
- func (e *Entry) WithField(key string, value any) *Entry
- func (e *Entry) WithFields(fielder Fielder) *Entry
- func (e Entry) WithLevel(level Level) *Entry
- type Field
- type Fielder
- type Fields
- type FieldsFunc
- type Handler
- type HandlerFunc
- type Level
- type LevelLogger
- type Logger
- type LoggerConfig
- type String
- type StringFunc
Constants ¶
This section is empty.
Variables ¶
var ErrInvalidLevel = errors.New("invalid level")
ErrInvalidLevel is returned if the severity level is invalid.
Functions ¶
This section is empty.
Types ¶
type Entry ¶
type Entry struct {
Level Level `json:"level"`
Timestamp time.Time `json:"timestamp"`
Fields Fields `json:"fields,omitempty"`
Message string `json:"message"`
// contains filtered or unexported fields
}
Entry represents a single log entry at a given log level.
func (*Entry) WithError ¶
WithError returns a new entry with the "error" set to `err`.
The given error may implement .Fielder, if it does the method will add all its `.Fields()` into the returned entry.
func (*Entry) WithFields ¶
type Fielder ¶
type Fielder interface {
Fields() Fields
}
Fielder is an interface for providing fields to custom types.
type Fields ¶
type Fields []Field
Fields represents a slice of entry level data used for structured logging.
type FieldsFunc ¶
type FieldsFunc func() Fields
func NewFieldsFunc ¶
func NewFieldsFunc(fn func() Fields) FieldsFunc
func (FieldsFunc) Fields ¶
func (f FieldsFunc) Fields() Fields
type Handler ¶
type Handler interface {
// HandleLog is invoked for each log event.
// Note that if the Entry is going to be used after the call to HandleLog returns,
// it must be cloned with Clone().
HandleLog(e *Entry) error
}
Handler is used to handle log events, outputting them to stdio or sending them to remote services. See the "handlers" directory for implementations.
It is left up to Handlers to implement thread-safety.
type HandlerFunc ¶
The HandlerFunc type is an adapter to allow the use of ordinary functions as log handlers. If f is a function with the appropriate signature, HandlerFunc(f) is a Handler object that calls f.
type Level ¶
type Level int
Level of severity.
func MustParseLevel ¶
MustParseLevel parses level string or panics.
func (*Level) UnmarshalJSON ¶
UnmarshalJSON implementation.
type LevelLogger ¶
type LevelLogger interface {
// Log logs a message at the given level using the string from calling s.String().
// Note that s.String() will not be called if the level is not enabled.
Log(s fmt.Stringer)
// WithLevel returns a new entry with `level` set.
WithLevel(Level) *Entry
// WithFields returns a new entry with the`fields` in fields set.
// This is a noop if LevelLogger's level is less than Logger's.
WithFields(fields Fielder) *Entry
// WithLevel returns a new entry with the field f set with value v
// This is a noop if LevelLogger's level is less than Logger's.
WithField(f string, v any) *Entry
// WithDuration returns a new entry with the "duration" field set
// to the given duration in milliseconds.
// This is a noop if LevelLogger's level is less than Logger's.
WithDuration(time.Duration) *Entry
// WithError returns a new entry with the "error" set to `err`.
// This is a noop if err is nil or LevelLogger's level is less than Logger's.
WithError(error) *Entry
}
LevelLogger is the logger at a given level.
type Logger ¶
type Logger interface {
// WithLevel returns a new entry with `level` set.
WithLevel(Level) *Entry
}
Logger is the main interface for the logger.
type LoggerConfig ¶
type LoggerConfig struct {
// Level is the minimum level to log at.
// If not set, defaults to InfoLevel.
Level Level
// Handler is the log handler to use.
Handler Handler
// Clock is the clock to use for timestamps.
// If not set, the system clock is used.
Clock Clock
}
LoggerConfig is the configuration used to create a logger.
type String ¶
type String string
String implements fmt.Stringer and can be used directly in the log methods.
type StringFunc ¶
type StringFunc func() string
StringFunc is a function that returns a string. It also implements the fmt.Stringer interface and can therefore be used as argument to the log methods.
func NewStringFunc ¶
func NewStringFunc(f func() string) StringFunc
NewStringFunc returns a StringFunc which implements Stringer.
func (StringFunc) String ¶
func (f StringFunc) String() string
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
cli
Package cli implements a colored text handler suitable for command-line interfaces.
|
Package cli implements a colored text handler suitable for command-line interfaces. |
|
json
Package json implements a JSON handler.
|
Package json implements a JSON handler. |
|
level
Package level implements a level filter handler.
|
Package level implements a level filter handler. |
|
memory
Package memory implements an in-memory handler useful for testing, as the entries can be accessed after writes.
|
Package memory implements an in-memory handler useful for testing, as the entries can be accessed after writes. |
|
multi
Package multi implements a handler which invokes a number of handlers.
|
Package multi implements a handler which invokes a number of handlers. |
|
text
Package text implements a development-friendly textual handler.
|
Package text implements a development-friendly textual handler. |