type Logger … // New constructs a new Logger from the provided zapcore.Core and Options. If // the passed zapcore.Core is nil, it falls 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, the highly-opinionated presets // (NewProduction, NewDevelopment, and NewExample) or the Config struct are // more convenient. // // For sample code, see the package-level AdvancedConfiguration example. func New(core zapcore.Core, options ...Option) *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 NewNop() *Logger { … } // 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 NewProduction(options ...Option) (*Logger, error) { … } // 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 NewDevelopment(options ...Option) (*Logger, error) { … } // Must is a helper that wraps a call to a function returning (*Logger, error) // and panics if the error is non-nil. It is intended for use in variable // initialization such as: // // var logger = zap.Must(zap.NewProduction()) func Must(logger *Logger, err error) *Logger { … } // NewExample builds a Logger that's designed for use in zap's testable // examples. It writes DebugLevel and above logs to standard out as JSON, but // omits the timestamp and calling function to keep example output // short and deterministic. func NewExample(options ...Option) *Logger { … } // Sugar wraps the Logger to provide a more ergonomic, but slightly slower, // API. Sugaring a Logger is quite inexpensive, so it's reasonable for a // single application to use both Loggers and SugaredLoggers, converting // between them on the boundaries of performance-sensitive code. func (log *Logger) Sugar() *SugaredLogger { … } // Named adds a new path segment to the logger's name. Segments are joined by // periods. By default, Loggers are unnamed. func (log *Logger) Named(s string) *Logger { … } // WithOptions clones the current Logger, applies the supplied Options, and // returns the resulting Logger. It's safe to use concurrently. func (log *Logger) WithOptions(opts ...Option) *Logger { … } // With creates a child logger and adds structured context to it. Fields added // to the child don't affect the parent, and vice versa. Any fields that // require evaluation (such as Objects) are evaluated upon invocation of With. func (log *Logger) With(fields ...Field) *Logger { … } // WithLazy creates a child logger and adds structured context to it lazily. // // The fields are evaluated only if the logger is further chained with [With] // or is written to with any of the log level methods. // Until that occurs, the logger may retain references to objects inside the fields, // and logging will reflect the state of an object at the time of logging, // not the time of WithLazy(). // // WithLazy provides a worthwhile performance optimization for contextual loggers // when the likelihood of using the child logger is low, // such as error paths and rarely taken branches. // // Similar to [With], fields added to the child don't affect the parent, and vice versa. func (log *Logger) WithLazy(fields ...Field) *Logger { … } // Level reports the minimum enabled level for this logger. // // For NopLoggers, this is [zapcore.InvalidLevel]. func (log *Logger) Level() zapcore.Level { … } // 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 (log *Logger) Check(lvl zapcore.Level, msg string) *zapcore.CheckedEntry { … } // Log logs a message at the specified level. The message includes any fields // passed at the log site, as well as any fields accumulated on the logger. // Any Fields that require evaluation (such as Objects) are evaluated upon // invocation of Log. func (log *Logger) Log(lvl zapcore.Level, msg string, fields ...Field) { … } // 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 (log *Logger) Debug(msg string, fields ...Field) { … } // 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 (log *Logger) Info(msg string, fields ...Field) { … } // 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 (log *Logger) Warn(msg string, fields ...Field) { … } // 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 (log *Logger) Error(msg string, fields ...Field) { … } // 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 (log *Logger) DPanic(msg string, fields ...Field) { … } // 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 (log *Logger) Panic(msg string, fields ...Field) { … } // 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 (log *Logger) Fatal(msg string, fields ...Field) { … } // Sync calls the underlying Core's Sync method, flushing any buffered log // entries. Applications should take care to call Sync before exiting. func (log *Logger) Sync() error { … } // Core returns the Logger's underlying zapcore.Core. func (log *Logger) Core() zapcore.Core { … } // Name returns the Logger's underlying name, // or an empty string if the logger is unnamed. func (log *Logger) Name() string { … } func (log *Logger) clone() *Logger { … } func (log *Logger) check(lvl zapcore.Level, msg string) *zapcore.CheckedEntry { … } func terminalHookOverride(defaultHook, override zapcore.CheckWriteHook) zapcore.CheckWriteHook { … }
Codebase Browser
kubernetes