Documentation
¶
Index ¶
- Variables
- func Configure(cfg Config) error
- func ConfigureWithOutputs(defaultLoggerCfg Config, outputs ...zapcore.Core) error
- func ConfigureWithTypedOutput(defaultLoggerCfg, typedLoggerCfg Config, key, value string, ...) error
- func ConsoleEncoderConfig() zapcore.EncoderConfig
- func Critical(format string, v ...interface{})
- func Debug(selector string, format string, v ...interface{})
- func DevelopmentSetup(options ...Option) error
- func Err(format string, v ...interface{})
- func GetLevel() zapcore.Level
- func HasSelector(selector string) bool
- func Info(format string, v ...interface{})
- func IsDebug(selector string) bool
- func JSONEncoderConfig() zapcore.EncoderConfig
- func MakeDebug(selector string) func(string, ...interface{})
- func ObserverLogs() *observer.ObservedLogs
- func Recover(msg string)
- func SetLevel(lvl zapcore.Level)
- func Sync() error
- func SyslogEncoderConfig() zapcore.EncoderConfig
- func TestingSetup(options ...Option) error
- func WTF(format string, v ...interface{})deprecated
- func Warn(format string, v ...interface{})
- type Config
- type Environment
- type FileConfig
- type Level
- type LogOption
- type Logger
- func (l *Logger) Core() zapcore.Core
- func (l *Logger) DPanic(args ...interface{})
- func (l *Logger) DPanicf(format string, args ...interface{})
- func (l *Logger) DPanicw(msg string, keysAndValues ...interface{})
- func (l *Logger) Debug(args ...interface{})
- func (l *Logger) Debugf(format string, args ...interface{})
- func (l *Logger) Debugw(msg string, keysAndValues ...interface{})
- func (l *Logger) Error(args ...interface{})
- func (l *Logger) Errorf(format string, args ...interface{})
- func (l *Logger) Errorw(msg string, keysAndValues ...interface{})
- func (l *Logger) Fatal(args ...interface{})
- func (l *Logger) Fatalf(format string, args ...interface{})
- func (l *Logger) Fatalw(msg string, keysAndValues ...interface{})
- func (l *Logger) Info(args ...interface{})
- func (l *Logger) Infof(format string, args ...interface{})
- func (l *Logger) Infow(msg string, keysAndValues ...interface{})
- func (l *Logger) IsDebug() bool
- func (l *Logger) Named(name string) *Logger
- func (l *Logger) Panic(args ...interface{})
- func (l *Logger) Panicf(format string, args ...interface{})
- func (l *Logger) Panicw(msg string, keysAndValues ...interface{})
- func (l *Logger) Recover(msg string)
- func (l *Logger) Sync() error
- func (l *Logger) Warn(args ...interface{})
- func (l *Logger) Warnf(format string, args ...interface{})
- func (l *Logger) Warnw(msg string, keysAndValues ...interface{})
- func (l *Logger) With(args ...interface{}) *Logger
- func (l *Logger) WithOptions(options ...LogOption) *Logger
- type MetricsConfig
- type Option
Constants ¶
This section is empty.
Variables ¶
var ( Any = zap.Any Array = zap.Array Binary = zap.Binary Bool = zap.Bool Bools = zap.Bools ByteString = zap.ByteString ByteStrings = zap.ByteStrings Complex64 = zap.Complex64 Complex64s = zap.Complex64s Complex128 = zap.Complex128 Complex128s = zap.Complex128s Duration = zap.Duration Durations = zap.Durations Error = zap.Error Errors = zap.Errors Float32 = zap.Float32 Float32s = zap.Float32s Float64 = zap.Float64 Float64s = zap.Float64s Int = zap.Int Ints = zap.Ints Int8 = zap.Int8 Int8s = zap.Int8s Int16 = zap.Int16 Int16s = zap.Int16s Int32 = zap.Int32 Int32s = zap.Int32s Int64 = zap.Int64 Int64s = zap.Int64s Namespace = zap.Namespace Reflect = zap.Reflect Stack = zap.Stack String = zap.String Stringer = zap.Stringer Strings = zap.Strings Time = zap.Time Times = zap.Times Uint = zap.Uint Uints = zap.Uints Uint8 = zap.Uint8 Uint8s = zap.Uint8s Uint16 = zap.Uint16 Uint16s = zap.Uint16s Uint32 = zap.Uint32 Uint32s = zap.Uint32s Uint64 = zap.Uint64 Uint64s = zap.Uint64s Uintptr = zap.Uintptr Uintptrs = zap.Uintptrs )
Field types for structured logging. Most fields are lazily marshaled so it is inexpensive to add fields to disabled log statements.
Functions ¶
func ConfigureWithOutputs ¶
ConfigureWithOutputs configures the global logger to use an output created from `defaultLoggerCfg` and all the outputs passed by `outputs`. This function needs to be exported because it's used by `logp/configure`
func ConfigureWithTypedOutput ¶ added in v0.9.6
func ConfigureWithTypedOutput(defaultLoggerCfg, typedLoggerCfg Config, key, value string, outputs ...zapcore.Core) error
ConfigureWithTypedOutput configures the global logger to use typed outputs.
If a log entry matches the defined key/value, this entry is logged using the core generated from `typedLoggerCfg`, otherwise it will be logged by all cores in `outputs` and the one generated from `defaultLoggerCfg`. Arguments:
- `defaultLoggerCfg` is used to create a new core that will be the default output from the logger
- `typedLoggerCfg` is used to create a new output that will only be used when the log entry matches `entry[logKey] = kind`
- `key` is the key the typed logger will look at
- `value` is the value compared against the `logKey` entry
- `outputs` is a list of cores that will be added together with the core generated by `defaultLoggerCfg` as the default output for the loggger.
If `defaultLoggerCfg.toObserver` is true, then `typedLoggerCfg` is ignored and a single sink is used so all logs can be observed.
func ConsoleEncoderConfig ¶
func ConsoleEncoderConfig() zapcore.EncoderConfig
func Critical ¶
func Critical(format string, v ...interface{})
Critical uses fmt.Sprintf to construct and log a message. It's an alias for Error. Deprecated: Use logp.NewLogger.
func DevelopmentSetup ¶
DevelopmentSetup configures the logger in development mode at debug level. By default the output goes to stderr.
func Err ¶
func Err(format string, v ...interface{})
Err uses fmt.Sprintf to construct and log a message. Deprecated: Use logp.NewLogger.
func HasSelector ¶
HasSelector returns true if the given selector was explicitly set.
func Info ¶
func Info(format string, v ...interface{})
Info uses fmt.Sprintf to construct and log a message. Deprecated: Use logp.NewLogger.
func IsDebug ¶
IsDebug returns true if the given selector would be logged. Deprecated: Use logp.NewLogger.
func JSONEncoderConfig ¶
func JSONEncoderConfig() zapcore.EncoderConfig
func MakeDebug ¶
MakeDebug returns a function that logs at debug level. Deprecated: Use logp.NewLogger.
func ObserverLogs ¶
func ObserverLogs() *observer.ObservedLogs
ObserverLogs provides the list of logs generated during the observation process.
func Sync ¶
func Sync() error
Sync flushes any buffered log entries. Applications should take care to call Sync before exiting.
func SyslogEncoderConfig ¶
func SyslogEncoderConfig() zapcore.EncoderConfig
func TestingSetup ¶
TestingSetup configures logging by calling DevelopmentSetup if and only if verbose testing is enabled (as in 'go test -v').
Types ¶
type Config ¶
type Config struct {
Beat string `config:",ignore"` // Name of the Beat (for default file name).
Level Level `config:"level"` // Logging level (error, warning, info, debug).
Selectors []string `config:"selectors"` // Selectors for debug level logging.
ToStderr bool `config:"to_stderr" yaml:"to_stderr"`
ToSyslog bool `config:"to_syslog" yaml:"to_syslog"`
ToFiles bool `config:"to_files" yaml:"to_files"`
ToEventLog bool `config:"to_eventlog" yaml:"to_eventlog"`
Files FileConfig `config:"files"`
Metrics MetricsConfig `config:"metrics"`
// contains filtered or unexported fields
}
Config contains the configuration options for the logger. To create a Config from a common.Config use logp/config.Build.
func DefaultConfig ¶
func DefaultConfig(environment Environment) Config
DefaultConfig returns the default config options for a given environment the Beat is supposed to be run within.
func DefaultEventConfig ¶ added in v0.9.6
func DefaultEventConfig(environment Environment) Config
DefaultEventConfig returns the default config options for the event logger in a given environment the Beat is supposed to be run within.
func (Config) LogFilename ¶
LogFilename returns the base filename to which logs will be written for the "files" log output. If another log output is used, or `logging.files.name` is unspecified, then the beat name will be returned.
type Environment ¶
type Environment int
Environment indicates the environment the logger is supped to be run in. The default logger configuration may be different for different environments.
const ( // DefaultEnvironment is used if the environment the process runs in is not known. DefaultEnvironment Environment = iota // SystemdEnvironment indicates that the process is started and managed by systemd. SystemdEnvironment // ContainerEnvironment indicates that the process is running within a container (docker, k8s, rkt, ...). ContainerEnvironment // MacOSServiceEnvironment indicates that the process is running as a daemon on macOS (e.g. managed via launchctl). MacOSServiceEnvironment // WindowsServiceEnvironment indicates the the process is run as a windows service. WindowsServiceEnvironment // InvalidEnvironment indicates that the environment name given is unknown or invalid. InvalidEnvironment )
func ParseEnvironment ¶
func ParseEnvironment(in string) Environment
ParseEnvironment returns the environment type by name. The parse is case insensitive. InvalidEnvironment is returned if the environment type is unknown.
func (Environment) String ¶
func (v Environment) String() string
String returns the string representation the configured environment
type FileConfig ¶
type FileConfig struct {
Path string `config:"path" yaml:"path"`
Name string `config:"name" yaml:"name"`
MaxSize uint `config:"rotateeverybytes" yaml:"rotateeverybytes" validate:"min=1"`
MaxBackups uint `config:"keepfiles" yaml:"keepfiles" validate:"max=1024"`
Permissions uint32 `config:"permissions"`
Interval time.Duration `config:"interval"`
RotateOnStartup bool `config:"rotateonstartup"`
RedirectStderr bool `config:"redirect_stderr" yaml:"redirect_stderr"`
}
FileConfig contains the configuration options for the file output.
type Level ¶
type Level int8
Level is a logging priority. Higher levels are more important.
const ( DebugLevel Level = iota - 1 InfoLevel WarnLevel ErrorLevel CriticalLevel // Critical exists only for config backward compatibility. )
Logging levels.
func (Level) MarshalJSON ¶
MarshalJSON marshals level in a correct form
func (Level) MarshalYAML ¶
MarshalYAML marshals level in a correct form
type Logger ¶
type Logger struct {
// contains filtered or unexported fields
}
Logger logs messages to the configured output.
func NewInMemory ¶ added in v0.9.2
NewInMemory returns a new in-memory logger along with the buffer to which it logs. It's goroutine safe, but operating directly on the returned buffer is not. This logger is primary intended for short and simple use-cases such as printing the full logs only when an operation fails. encCfg configures the log format, use logp.ConsoleEncoderConfig for console format, logp.JSONEncoderConfig for JSON or any other valid zapcore.EncoderConfig.
func NewLogger ¶
NewLogger returns a new Logger labeled with the name of the selector. This should never be used from any global contexts, otherwise you will receive a no-op Logger. This is because the logp package needs to be initialized first. Instead create new Logger instance that your object reuses. Or if you need to log from a static context then you may use logp.L().Infow(), for example.
func (*Logger) DPanic ¶
func (l *Logger) DPanic(args ...interface{})
DPanic uses fmt.Sprint to construct and log a message. In development, the logger then panics.
func (*Logger) DPanicf ¶
DPanicf uses fmt.Sprintf to log a templated message. In development, the logger then panics.
func (*Logger) DPanicw ¶
DPanicw logs a message with some additional context. The logger panics only in Development mode. The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
func (*Logger) Debug ¶
func (l *Logger) Debug(args ...interface{})
Debug uses fmt.Sprint to construct and log a message.
func (*Logger) Debugw ¶
Debugw logs a message with some additional context. The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
func (*Logger) Error ¶
func (l *Logger) Error(args ...interface{})
Error uses fmt.Sprint to construct and log a message.
func (*Logger) Errorw ¶
Errorw logs a message with some additional context. The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
func (*Logger) Fatal ¶
func (l *Logger) Fatal(args ...interface{})
Fatal uses fmt.Sprint to construct and log a message, then calls os.Exit(1).
func (*Logger) Fatalw ¶
Fatalw logs a message with some additional context, then calls os.Exit(1). The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
func (*Logger) Info ¶
func (l *Logger) Info(args ...interface{})
Info uses fmt.Sprint to construct and log a message.
func (*Logger) Infow ¶
Infow logs a message with some additional context. The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
func (*Logger) Named ¶
Named adds a new path segment to the logger's name. Segments are joined by periods.
func (*Logger) Panic ¶
func (l *Logger) Panic(args ...interface{})
Panic uses fmt.Sprint to construct and log a message, then panics.
func (*Logger) Panicw ¶
Panicw logs a message with some additional context, then panics. The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
func (*Logger) Warn ¶
func (l *Logger) Warn(args ...interface{})
Warn uses fmt.Sprint to construct and log a message.
func (*Logger) Warnw ¶
Warnw logs a message with some additional context. The additional context is added in the form of key-value pairs. The optimal way to write the value to the log message will be inferred by the value's type. To explicitly specify a type you can pass a Field such as logp.Stringer.
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 returns a clone of l with options applied.
type MetricsConfig ¶
type MetricsConfig struct {
Enabled bool `config:"enabled"`
Period time.Duration `config:"period"`
}
MetricsConfig contains configuration used by the monitor to output metrics into the logstream.
Currently these options are not used through this object in beats (as monitoring is setup elsewhere).
type Option ¶
type Option func(cfg *Config)
Option configures the logp package behavior.
func ToDiscardOutput ¶
func ToDiscardOutput() Option
ToDiscardOutput configures the logger to write to io.Discard. This is for benchmarking purposes only.
func ToObserverOutput ¶
func ToObserverOutput() Option
ToObserverOutput specifies that the output should be collected in memory so that they can be read by an observer by calling ObserverLogs().
func WithSelectors ¶
WithSelectors specifies what debug selectors are enabled. If no selectors are specified then they are all enabled.
Source Files
Directories