Documentation ¶
Overview ¶
Package zap provides fast, structured, leveled logging in Go.
Index ¶
- Constants
- func Any(key string, value interface{}) zapcore.Field
- func Array(key string, val zapcore.ArrayMarshaler) zapcore.Field
- func Binary(key string, val []byte) zapcore.Field
- func Bool(key string, val bool) zapcore.Field
- func Bools(key string, bs []bool) zapcore.Field
- func Complex128(key string, val complex128) zapcore.Field
- func Complex128s(key string, nums []complex128) zapcore.Field
- func Complex64(key string, val complex64) zapcore.Field
- func Complex64s(key string, nums []complex64) zapcore.Field
- func Duration(key string, val time.Duration) zapcore.Field
- func Durations(key string, ds []time.Duration) zapcore.Field
- func Error(err error) zapcore.Field
- func Errors(key string, errs []error) zapcore.Field
- func Float32(key string, val float32) zapcore.Field
- func Float32s(key string, nums []float32) zapcore.Field
- func Float64(key string, val float64) zapcore.Field
- func Float64s(key string, nums []float64) zapcore.Field
- func Int(key string, val int) zapcore.Field
- func Int16(key string, val int16) zapcore.Field
- func Int16s(key string, nums []int16) zapcore.Field
- func Int32(key string, val int32) zapcore.Field
- func Int32s(key string, nums []int32) zapcore.Field
- func Int64(key string, val int64) zapcore.Field
- func Int64s(key string, nums []int64) zapcore.Field
- func Int8(key string, val int8) zapcore.Field
- func Int8s(key string, nums []int8) zapcore.Field
- func Ints(key string, nums []int) zapcore.Field
- func LevelFlag(name string, defaultLevel zapcore.Level, usage string) *zapcore.Level
- func NamedError(key string, err error) zapcore.Field
- func Namespace(key string) zapcore.Field
- func NewDevelopmentEncoderConfig() zapcore.EncoderConfig
- func NewProductionEncoderConfig() zapcore.EncoderConfig
- func NewStdLog(l *Logger) *log.Logger
- func Object(key string, val zapcore.ObjectMarshaler) zapcore.Field
- func Open(paths ...string) (zapcore.WriteSyncer, func(), error)
- func RedirectStdLog(l *Logger) func()
- func Reflect(key string, val interface{}) zapcore.Field
- func ReplaceGlobals(logger *Logger) func()
- func Skip() zapcore.Field
- func Stack(key string) zapcore.Field
- func String(key string, val string) zapcore.Field
- func Stringer(key string, val fmt.Stringer) zapcore.Field
- func Strings(key string, ss []string) zapcore.Field
- func Time(key string, val time.Time) zapcore.Field
- func Times(key string, ts []time.Time) zapcore.Field
- func Uint(key string, val uint) zapcore.Field
- func Uint16(key string, val uint16) zapcore.Field
- func Uint16s(key string, nums []uint16) zapcore.Field
- func Uint32(key string, val uint32) zapcore.Field
- func Uint32s(key string, nums []uint32) zapcore.Field
- func Uint64(key string, val uint64) zapcore.Field
- func Uint64s(key string, nums []uint64) zapcore.Field
- func Uint8(key string, val uint8) zapcore.Field
- func Uint8s(key string, nums []uint8) zapcore.Field
- func Uintptr(key string, val uintptr) zapcore.Field
- func Uintptrs(key string, us []uintptr) zapcore.Field
- func Uints(key string, nums []uint) zapcore.Field
- type AtomicLevel
- type Config
- type LevelEnablerFunc
- type Logger
- func (log *Logger) Check(lvl zapcore.Level, msg string) *zapcore.CheckedEntry
- func (log *Logger) Core() zapcore.Core
- func (log *Logger) DPanic(msg string, fields ...zapcore.Field)
- func (log *Logger) Debug(msg string, fields ...zapcore.Field)
- func (log *Logger) Error(msg string, fields ...zapcore.Field)
- func (log *Logger) Fatal(msg string, fields ...zapcore.Field)
- func (log *Logger) Info(msg string, fields ...zapcore.Field)
- func (log *Logger) Named(s string) *Logger
- func (log *Logger) Panic(msg string, fields ...zapcore.Field)
- func (log *Logger) Sugar() *SugaredLogger
- func (log *Logger) Warn(msg string, fields ...zapcore.Field)
- func (log *Logger) With(fields ...zapcore.Field) *Logger
- func (log *Logger) WithOptions(opts ...Option) *Logger
- type Option
- func AddCaller() Option
- func AddCallerSkip(skip int) Option
- func AddStacktrace(lvl zapcore.LevelEnabler) Option
- func Development() Option
- func ErrorOutput(w zapcore.WriteSyncer) Option
- func Fields(fs ...zapcore.Field) Option
- func Hooks(hooks ...func(zapcore.Entry) error) Option
- func WrapCore(f func(zapcore.Core) zapcore.Core) Option
- type SamplingConfig
- type SugaredLogger
- func (s *SugaredLogger) DPanic(args ...interface{})
- func (s *SugaredLogger) DPanicf(template string, args ...interface{})
- func (s *SugaredLogger) DPanicw(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) Debug(args ...interface{})
- func (s *SugaredLogger) Debugf(template string, args ...interface{})
- func (s *SugaredLogger) Debugw(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) Desugar() *Logger
- func (s *SugaredLogger) Error(args ...interface{})
- func (s *SugaredLogger) Errorf(template string, args ...interface{})
- func (s *SugaredLogger) Errorw(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) Fatal(args ...interface{})
- func (s *SugaredLogger) Fatalf(template string, args ...interface{})
- func (s *SugaredLogger) Fatalw(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) Info(args ...interface{})
- func (s *SugaredLogger) Infof(template string, args ...interface{})
- func (s *SugaredLogger) Infow(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) Named(name string) *SugaredLogger
- func (s *SugaredLogger) Panic(args ...interface{})
- func (s *SugaredLogger) Panicf(template string, args ...interface{})
- func (s *SugaredLogger) Panicw(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) Warn(args ...interface{})
- func (s *SugaredLogger) Warnf(template string, args ...interface{})
- func (s *SugaredLogger) Warnw(msg string, keysAndValues ...interface{})
- func (s *SugaredLogger) With(args ...interface{}) *SugaredLogger
Constants ¶
const ( // DebugLevel logs are typically voluminous, and are usually disabled in // production. DebugLevel = zapcore.DebugLevel // InfoLevel is the default logging priority. InfoLevel = zapcore.InfoLevel // WarnLevel logs are more important than Info, but don't need individual // human review. WarnLevel = zapcore.WarnLevel // ErrorLevel logs are high-priority. If an application is running smoothly, // it shouldn't generate any error-level logs. ErrorLevel = zapcore.ErrorLevel // DPanicLevel logs are particularly important errors. In development the // logger panics after writing the message. DPanicLevel = zapcore.DPanicLevel // PanicLevel logs a message, then panics. PanicLevel = zapcore.PanicLevel // FatalLevel logs a message, then calls os.Exit(1). FatalLevel = zapcore.FatalLevel )
Variables ¶
This section is empty.
Functions ¶
func Any ¶
Any takes a key and an arbitrary value and chooses the best way to represent them as a field, falling back to a reflection-based approach only if necessary.
Since byte/uint8 and rune/int32 are aliases, Any can't differentiate between them. To minimize suprise, []byte values are treated as binary blobs, byte values are treated as uint8, and runes are always treated as integers.
func Array ¶
func Array(key string, val zapcore.ArrayMarshaler) zapcore.Field
Array constructs a field with the given key and ArrayMarshaler. It provides a flexible, but still type-safe and efficient, way to add array-like types to the logging context. The struct's MarshalLogArray method is called lazily.
func Binary ¶
Binary constructs a field that carries an opaque binary blob.
Binary data is serialized in an encoding-appropriate format. For example, zap's JSON encoder base64-encodes binary blobs.
func Complex128 ¶
func Complex128(key string, val complex128) zapcore.Field
Complex128 constructs a field that carries a complex number. Unlike most numeric fields, this costs an allocation (to convert the complex128 to interface{}).
func Complex128s ¶
func Complex128s(key string, nums []complex128) zapcore.Field
Complex128s constructs a field that carries a slice of complex numbers.
func Complex64 ¶
Complex64 constructs a field that carries a complex number. Unlike most numeric fields, this costs an allocation (to convert the complex64 to interface{}).
func Complex64s ¶
Complex64s constructs a field that carries a slice of complex numbers.
func Duration ¶
Duration constructs a field with the given key and value. The encoder controls how the duration is serialized.
func Float32 ¶
Float32 constructs a field that carries a float32. The way the floating-point value is represented is encoder-dependent, so marshaling is necessarily lazy.
func Float64 ¶
Float64 constructs a field that carries a float64. The way the floating-point value is represented is encoder-dependent, so marshaling is necessarily lazy.
func LevelFlag ¶
LevelFlag defines a Level flag with specified name, default value and usage string. The return value is the address of a Level value that stores the value of the flag.
Note that you can also use any non-nil *Level as a flag.Value.
func NamedError ¶
NamedError constructs a field that lazily stores err.Error() under the provided key. Errors which also implement fmt.Formatter (like those produced by github.com/pkg/errors) will also have their verbose representation stored under key+"Verbose". If passed a nil error, the field is a no-op.
For the common case in which the key is simply "error", the Error function is shorter and less repetitive.
func Namespace ¶
Namespace creates a named, isolated scope within the logger's context. All subsequent fields will be added to the new namespace.
This helps prevent key collisions when injecting loggers into sub-components or third-party libraries.
func NewDevelopmentEncoderConfig ¶
func NewDevelopmentEncoderConfig() zapcore.EncoderConfig
NewDevelopmentEncoderConfig returns an opinionated EncoderConfig for development environments.
func NewProductionEncoderConfig ¶
func NewProductionEncoderConfig() zapcore.EncoderConfig
NewProductionEncoderConfig returns an opinionated EncoderConfig for production environments.
func NewStdLog ¶
NewStdLog returns a *log.Logger which writes to the supplied zap Logger at InfoLevel. To redirect the standard library's package-global logging functions, use RedirectStdLog instead.
func Object ¶
func Object(key string, val zapcore.ObjectMarshaler) zapcore.Field
Object constructs a field with the given key and ObjectMarshaler. It provides a flexible, but still type-safe and efficient, way to add map- or struct-like user-defined types to the logging context. The struct's MarshalLogObject method is called lazily.
func Open ¶
func Open(paths ...string) (zapcore.WriteSyncer, func(), error)
Open is a high-level wrapper that takes a variadic number of paths, opens or creates each of the specified files, and combines them into a locked WriteSyncer. It also returns any error encountered and a function to close any opened files.
Passing no paths returns a no-op WriteSyncer. The special paths "stdout" and "stderr" are interpreted as os.Stdout and os.Stderr, respectively.
func RedirectStdLog ¶
func RedirectStdLog(l *Logger) func()
RedirectStdLog redirects output from the standard library's package-global logger to the supplied logger at InfoLevel. Since zap already handles caller annotations, timestamps, etc., it automatically disables the standard library's annotations and prefixing.
It returns a function to restore the original prefix and flags and reset the standard library's output to os.Stdout.
func Reflect ¶
Reflect constructs a field with the given key and an arbitrary object. It uses an encoding-appropriate, reflection-based function to lazily serialize nearly any object into the logging context, but it's relatively slow and allocation-heavy. Outside tests, Any is always a better choice.
If encoding fails (e.g., trying to serialize a map[int]string to JSON), Reflect includes the error message in the final log output.
func ReplaceGlobals ¶
func ReplaceGlobals(logger *Logger) func()
ReplaceGlobals replaces the global Logger and the SugaredLogger, and returns a function to restore the original values.
It's safe for concurrent use.
func Stack ¶
Stack constructs a field that stores a stacktrace of the current goroutine under provided key. Keep in mind that taking a stacktrace is eager and expensive (relatively speaking); this function both makes an allocation and takes about two microseconds.
func Stringer ¶
Stringer constructs a field with the given key and the output of the value's String method. The Stringer's String method is called lazily.
func Time ¶
Time constructs a zapcore.Field with the given key and value. The encoder controls how the time is serialized.
Types ¶
type AtomicLevel ¶
type AtomicLevel struct {
// contains filtered or unexported fields
}
An AtomicLevel is an atomically changeable, dynamic logging level. It lets you safely change the log level of a tree of loggers (the root logger and any children created by adding context) at runtime.
The AtomicLevel itself is an http.Handler that serves a JSON endpoint to alter its level.
AtomicLevels must be created with the NewAtomicLevel constructor to allocate their internal atomic pointer.
func NewAtomicLevel ¶
func NewAtomicLevel() AtomicLevel
NewAtomicLevel creates an AtomicLevel with InfoLevel and above logging enabled.
func (AtomicLevel) Enabled ¶
func (lvl AtomicLevel) Enabled(l zapcore.Level) bool
Enabled implements the zapcore.LevelEnabler interface, which allows the AtomicLevel to be used in place of traditional static levels.
func (AtomicLevel) Level ¶
func (lvl AtomicLevel) Level() zapcore.Level
Level returns the minimum enabled log level.
func (AtomicLevel) ServeHTTP ¶
func (lvl AtomicLevel) ServeHTTP(w http.ResponseWriter, r *http.Request)
ServeHTTP is a simple JSON endpoint that can report on or change the current logging level.
GET requests return a JSON description of the current logging level. PUT requests change the logging level and expect a payload like:
{"level":"info"}
It's perfectly safe to change the logging level while a program is running.
func (AtomicLevel) SetLevel ¶
func (lvl AtomicLevel) SetLevel(l zapcore.Level)
SetLevel alters the logging level.
func (*AtomicLevel) UnmarshalText ¶
func (lvl *AtomicLevel) UnmarshalText(text []byte) error
UnmarshalText unmarshals the text to an AtomicLevel. It uses the same text representations as the static zapcore.Levels ("debug", "info", "warn", "error", "dpanic", "panic", and "fatal").
type Config ¶
type Config struct { // Level is the minimum enabled logging level. Note that this is a dynamic // level, so calling Config.Level.SetLevel will atomically change the log // level of all loggers descended from this config. The zero value is // InfoLevel. Level AtomicLevel `json:"level" yaml:"level"` // Development puts the logger in development mode, which changes the // behavior of DPanicLevel and takes stacktraces more liberally. Development bool `json:"development" yaml:"development"` // DisableCaller stops annotating logs with the calling function's file // name and line number. By default, all logs are annotated. DisableCaller bool `json:"disableCaller" yaml:"disableCaller"` // DisableStacktrace completely disables automatic stacktrace capturing. By // default, stacktraces are captured for WarnLevel and above logs in // development and ErrorLevel and above in production. DisableStacktrace bool `json:"disableStacktrace" yaml:"disableStacktrace"` // Sampling sets a sampling policy. A nil SamplingConfig disables sampling. Sampling *SamplingConfig `json:"sampling" yaml:"sampling"` // Encoding sets the logger's encoding. Valid values are "json" and // "console". Encoding string `json:"encoding" yaml:"encoding"` // EncoderConfig sets options for the chosen encoder. See // zapcore.EncoderConfig for details. EncoderConfig zapcore.EncoderConfig `json:"encoderConfig" yaml:"encoderConfig"` // OutputPaths is a list of paths to write logging output to. See Open for // details. OutputPaths []string `json:"outputPaths" yaml:"outputPaths"` // ErrorOutputPaths is a list of paths to write internal logger errors to. // The default is standard error. ErrorOutputPaths []string `json:"errorOutputPaths" yaml:"errorOutputPaths"` // InitialFields is a collection of fields to add to the root logger. InitialFields map[string]interface{} `json:"initialFields" yaml:"initialFields"` }
Config offers a declarative way to construct a logger.
It doesn't do anything that can't be done with New, Options, and the various zapcore.WriteSyncer and zapcore.Core wrappers, but it's a simpler way to toggle common options.
func NewDevelopmentConfig ¶
func NewDevelopmentConfig() Config
NewDevelopmentConfig is a reasonable development configuration. Logging is enabled at DebugLevel and above.
It enables development mode (which makes DPanicLevel logs panic), uses a console encoder, writes to standard error, and disables sampling. Stacktraces are automatically included on logs of WarnLevel and above.
func NewProductionConfig ¶
func NewProductionConfig() Config
NewProductionConfig is the recommended production configuration. Logging is enabled at InfoLevel and above.
It uses a JSON encoder, writes to standard error, and enables sampling. Stacktraces are automatically included on logs of ErrorLevel and above.
type LevelEnablerFunc ¶
LevelEnablerFunc is a convenient way to implement zapcore.LevelEnabler with an anonymous function.
type Logger ¶
type Logger struct {
// contains filtered or unexported fields
}
A Logger provides fast, leveled, structured logging. All methods are safe for concurrent use.
If you'd prefer a slower but less verbose logger, see the SugaredLogger.
func L ¶
func L() *Logger
L returns the global Logger, which can be reconfigured with ReplaceGlobals.
It's safe for concurrent use.
func New ¶
New constructs a new Logger from the provided zapcore.Core and Options. If the passed zapcore.Core is nil, we fall back to using a no-op implementation.
This is the most flexible way to construct a Logger, but also the most verbose. For typical use cases, NewProduction and NewDevelopment are more convenient.
func NewDevelopment ¶
NewDevelopment builds a development Logger that writes DebugLevel and above logs to standard error in a human-friendly format.
It's a shortcut for NewDevelopmentConfig().Build(...Option).
func NewNop ¶
func NewNop() *Logger
NewNop returns a no-op Logger. It never writes out logs or internal errors, and it never runs user-defined hooks.
Using WithOptions to replace the Core or error output of a no-op Logger can re-enable logging.
func NewProduction ¶
NewProduction builds a sensible production Logger that writes InfoLevel and above logs to standard error as JSON.
It's a shortcut for NewProductionConfig().Build(...Option).
func (*Logger) Check ¶
Check returns a CheckedEntry if logging a message at the specified level is enabled. It's a completely optional optimization; in high-performance applications, Check can help avoid allocating a slice to hold fields.
func (*Logger) DPanic ¶
DPanic logs a message at DPanicLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
If the logger is in development mode, it then panics (DPanic means "development panic"). This is useful for catching errors that are recoverable, but shouldn't ever happen.
func (*Logger) Debug ¶
Debug logs a message at DebugLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
func (*Logger) Error ¶
Error logs a message at ErrorLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
func (*Logger) Fatal ¶
Fatal logs a message at FatalLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
The logger then calls os.Exit(1), even if logging at FatalLevel is disabled.
func (*Logger) Info ¶
Info logs a message at InfoLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
func (*Logger) Named ¶
Named adds a new path segment to the logger's name. Segments are joined by periods.
func (*Logger) Panic ¶
Panic logs a message at PanicLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
The logger then panics, even if logging at PanicLevel is disabled.
func (*Logger) Sugar ¶
func (log *Logger) Sugar() *SugaredLogger
Sugar converts a Logger to a SugaredLogger.
func (*Logger) Warn ¶
Warn logs a message at WarnLevel. The message includes any fields passed at the log site, as well as any fields accumulated on the logger.
func (*Logger) With ¶
With creates a child logger and adds structured context to it. Fields added to the child don't affect the parent, and vice versa.
func (*Logger) WithOptions ¶
WithOptions clones the current Logger, applies the supplied Options, and returns the resulting Logger. It's safe to use concurrently.
type Option ¶
type Option interface {
// contains filtered or unexported methods
}
Option is used to set options for the logger.
func AddCaller ¶
func AddCaller() Option
AddCaller configures the Logger to annotate each message with the filename and line number of zap's caller.
func AddCallerSkip ¶
AddCallerSkip increases the number of callers skipped by caller annotation (as enabled by the AddCaller option).
func AddStacktrace ¶
func AddStacktrace(lvl zapcore.LevelEnabler) Option
AddStacktrace configures the Logger to record a stack trace for all messages at or above a given level.
func Development ¶
func Development() Option
Development puts the logger in development mode, which alters the behavior of the DPanic method.
func ErrorOutput ¶
func ErrorOutput(w zapcore.WriteSyncer) Option
ErrorOutput sets the destination for errors generated by the logger. The supplied WriteSyncer is automatically wrapped with a mutex, so it need not be safe for concurrent use.
type SamplingConfig ¶
type SamplingConfig struct { Initial int `json:"initial" yaml:"initial"` Thereafter int `json:"thereafter" yaml:"thereafter"` }
SamplingConfig sets a sampling strategy for the logger. Sampling caps the global CPU and I/O load that logging puts on your process while attempting to preserve a representative subset of your logs.
Values configured here are per-second. See zapcore.NewSampler for details.
type SugaredLogger ¶
type SugaredLogger struct {
// contains filtered or unexported fields
}
A SugaredLogger wraps the base Logger functionality in a slower, but less verbose, API. Any Logger can be converted to a SugaredLogger with its Sugar method.
func S ¶
func S() *SugaredLogger
S returns the global SugaredLogger, which can be reconfigured with ReplaceGlobals.
It's safe for concurrent use.
func (*SugaredLogger) DPanic ¶
func (s *SugaredLogger) DPanic(args ...interface{})
DPanic uses fmt.Sprint to construct and log a message. In development, the logger then panics. (See DPanicLevel for details.)
func (*SugaredLogger) DPanicf ¶
func (s *SugaredLogger) DPanicf(template string, args ...interface{})
DPanicf uses fmt.Sprintf to log a templated message. In development, the logger then panics. (See DPanicLevel for details.)
func (*SugaredLogger) DPanicw ¶
func (s *SugaredLogger) DPanicw(msg string, keysAndValues ...interface{})
DPanicw logs a message with some additional context. In development, the logger then panics. (See DPanicLevel for details.) The variadic key-value pairs are treated as they are in With.
func (*SugaredLogger) Debug ¶
func (s *SugaredLogger) Debug(args ...interface{})
Debug uses fmt.Sprint to construct and log a message.
func (*SugaredLogger) Debugf ¶
func (s *SugaredLogger) Debugf(template string, args ...interface{})
Debugf uses fmt.Sprintf to log a templated message.
func (*SugaredLogger) Debugw ¶
func (s *SugaredLogger) Debugw(msg string, keysAndValues ...interface{})
Debugw logs a message with some additional context. The variadic key-value pairs are treated as they are in With.
When debug-level logging is disabled, this is much faster than
s.With(keysAndValues).Debug(msg)
func (*SugaredLogger) Desugar ¶
func (s *SugaredLogger) Desugar() *Logger
Desugar unwraps a SugaredLogger, exposing the original Logger.
func (*SugaredLogger) Error ¶
func (s *SugaredLogger) Error(args ...interface{})
Error uses fmt.Sprint to construct and log a message.
func (*SugaredLogger) Errorf ¶
func (s *SugaredLogger) Errorf(template string, args ...interface{})
Errorf uses fmt.Sprintf to log a templated message.
func (*SugaredLogger) Errorw ¶
func (s *SugaredLogger) Errorw(msg string, keysAndValues ...interface{})
Errorw logs a message with some additional context. The variadic key-value pairs are treated as they are in With.
func (*SugaredLogger) Fatal ¶
func (s *SugaredLogger) Fatal(args ...interface{})
Fatal uses fmt.Sprint to construct and log a message, then calls os.Exit.
func (*SugaredLogger) Fatalf ¶
func (s *SugaredLogger) Fatalf(template string, args ...interface{})
Fatalf uses fmt.Sprintf to log a templated message, then calls os.Exit.
func (*SugaredLogger) Fatalw ¶
func (s *SugaredLogger) Fatalw(msg string, keysAndValues ...interface{})
Fatalw logs a message with some additional context, then calls os.Exit. The variadic key-value pairs are treated as they are in With.
func (*SugaredLogger) Info ¶
func (s *SugaredLogger) Info(args ...interface{})
Info uses fmt.Sprint to construct and log a message.
func (*SugaredLogger) Infof ¶
func (s *SugaredLogger) Infof(template string, args ...interface{})
Infof uses fmt.Sprintf to log a templated message.
func (*SugaredLogger) Infow ¶
func (s *SugaredLogger) Infow(msg string, keysAndValues ...interface{})
Infow logs a message with some additional context. The variadic key-value pairs are treated as they are in With.
func (*SugaredLogger) Named ¶
func (s *SugaredLogger) Named(name string) *SugaredLogger
Named adds a sub-scope to the logger's name. See Logger.Named for details.
func (*SugaredLogger) Panic ¶
func (s *SugaredLogger) Panic(args ...interface{})
Panic uses fmt.Sprint to construct and log a message, then panics.
func (*SugaredLogger) Panicf ¶
func (s *SugaredLogger) Panicf(template string, args ...interface{})
Panicf uses fmt.Sprintf to log a templated message, then panics.
func (*SugaredLogger) Panicw ¶
func (s *SugaredLogger) Panicw(msg string, keysAndValues ...interface{})
Panicw logs a message with some additional context, then panics. The variadic key-value pairs are treated as they are in With.
func (*SugaredLogger) Warn ¶
func (s *SugaredLogger) Warn(args ...interface{})
Warn uses fmt.Sprint to construct and log a message.
func (*SugaredLogger) Warnf ¶
func (s *SugaredLogger) Warnf(template string, args ...interface{})
Warnf uses fmt.Sprintf to log a templated message.
func (*SugaredLogger) Warnw ¶
func (s *SugaredLogger) Warnw(msg string, keysAndValues ...interface{})
Warnw logs a message with some additional context. The variadic key-value pairs are treated as they are in With.
func (*SugaredLogger) With ¶
func (s *SugaredLogger) With(args ...interface{}) *SugaredLogger
With adds a variadic number of fields to the logging context. It accepts a mix of strongly-typed zapcore.Field objects and loosely-typed key-value pairs. When processing pairs, the first element of the pair is used as the field key and the second as the field value.
For example,
sugaredLogger.With( "hello", "world", "failure", errors.New("oh no"), Stack(), "count", 42, "user", User{Name: "alice"}, )
is the equivalent of
baseLogger.With( String("hello", "world"), String("failure", "oh no"), Stack(), Int("count", 42), Object("user", User{Name: "alice"}), )
Note that the keys in key-value pairs should be strings. In development, passing a non-string key panics. In production, the logger is more forgiving: a separate error is logged, but the key-value pair is skipped and execution continues. Passing an orphaned key triggers similar behavior: panics in development and errors in production.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Package benchmarks contains only benchmarks comparing zap to other structured logging libraries.
|
Package benchmarks contains only benchmarks comparing zap to other structured logging libraries. |
Package buffer provides a thin wrapper around a byte slice.
|
Package buffer provides a thin wrapper around a byte slice. |
internal
|
|
bufferpool
Package bufferpool provides strongly-typed functions to interact with a shared pool of byte buffers.
|
Package bufferpool provides strongly-typed functions to interact with a shared pool of byte buffers. |
color
Package color adds coloring functionality for TTY output.
|
Package color adds coloring functionality for TTY output. |
exit
Package exit provides stubs so that unit tests can exercise code that calls os.Exit(1).
|
Package exit provides stubs so that unit tests can exercise code that calls os.Exit(1). |
multierror
Package multierror provides a simple way to treat a collection of errors as a single error.
|
Package multierror provides a simple way to treat a collection of errors as a single error. |
Package testutils provides some simple testing helpers (most of which aren't specifically logging-related).
|
Package testutils provides some simple testing helpers (most of which aren't specifically logging-related). |
Package zapcore defines and implements the low-level interfaces upon which zap is built.
|
Package zapcore defines and implements the low-level interfaces upon which zap is built. |