Documentation

Overview

    Package zap contains helpers for setting up a new logr.Logger instance using the Zap logging framework.

    Package zap contains helpers for setting up a new logr.Logger instance using the Zap logging framework.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func ConsoleEncoder

    func ConsoleEncoder(opts ...EncoderConfigOption) func(o *Options)

      ConsoleEncoder configures the logger to use a Console encoder

      func Encoder

      func Encoder(encoder zapcore.Encoder) func(o *Options)

        Encoder configures how the logger will encode the output e.g JSON or console. See Options.Encoder

        func JSONEncoder

        func JSONEncoder(opts ...EncoderConfigOption) func(o *Options)

          JSONEncoder configures the logger to use a JSON Encoder

          func Level

          func Level(level zapcore.LevelEnabler) func(o *Options)

            Level sets the the minimum enabled logging level e.g Debug, Info See Options.Level

            func New

            func New(opts ...Opts) logr.Logger

              New returns a brand new Logger configured with Opts. It uses KubeAwareEncoder which adds Type information and Namespace/Name to the log.

              func NewRaw

              func NewRaw(opts ...Opts) *zap.Logger

                NewRaw returns a new zap.Logger configured with the passed Opts or their defaults. It uses KubeAwareEncoder which adds Type information and Namespace/Name to the log.

                func RawZapOpts

                func RawZapOpts(zapOpts ...zap.Option) func(o *Options)

                  RawZapOpts allows appending arbitrary zap.Options to configure the underlying zap logger. See Options.ZapOpts

                  func StacktraceLevel

                  func StacktraceLevel(stacktraceLevel zapcore.LevelEnabler) func(o *Options)

                    StacktraceLevel configures the logger to record a stack trace for all messages at or above a given level. See Options.StacktraceLevel

                    Types

                    type EncoderConfigOption

                    type EncoderConfigOption func(*zapcore.EncoderConfig)

                      EncoderConfigOption is a function that can modify a `zapcore.EncoderConfig`.

                      type KubeAwareEncoder

                      type KubeAwareEncoder struct {
                      	// Encoder is the zapcore.Encoder that this encoder delegates to
                      	zapcore.Encoder
                      
                      	// Verbose controls whether or not the full object is printed.
                      	// If false, only name, namespace, api version, and kind are printed.
                      	// Otherwise, the full object is logged.
                      	Verbose bool
                      }

                        KubeAwareEncoder is a Kubernetes-aware Zap Encoder. Instead of trying to force Kubernetes objects to implement ObjectMarshaller, we just implement a wrapper around a normal ObjectMarshaller that checks for Kubernetes objects.

                        func (*KubeAwareEncoder) Clone

                        func (k *KubeAwareEncoder) Clone() zapcore.Encoder

                          Clone implements zapcore.Encoder

                          func (*KubeAwareEncoder) EncodeEntry

                          func (k *KubeAwareEncoder) EncodeEntry(entry zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error)

                            EncodeEntry implements zapcore.Encoder

                            type NewEncoderFunc

                            type NewEncoderFunc func(...EncoderConfigOption) zapcore.Encoder

                              NewEncoderFunc is a function that creates an Encoder using the provided EncoderConfigOptions.

                              type Options

                              type Options struct {
                              	// Development configures the logger to use a Zap development config
                              	// (stacktraces on warnings, no sampling), otherwise a Zap production
                              	// config will be used (stacktraces on errors, sampling).
                              	Development bool
                              	// Encoder configures how Zap will encode the output.  Defaults to
                              	// console when Development is true and JSON otherwise
                              	Encoder zapcore.Encoder
                              	// EncoderConfigOptions can modify the EncoderConfig needed to initialize an Encoder.
                              	// See https://godoc.org/go.uber.org/zap/zapcore#EncoderConfig for the list of options
                              	// that can be configured.
                              	// Note that the EncoderConfigOptions are not applied when the Encoder option is already set.
                              	EncoderConfigOptions []EncoderConfigOption
                              	// NewEncoder configures Encoder using the provided EncoderConfigOptions.
                              	// Note that the NewEncoder function is not used when the Encoder option is already set.
                              	NewEncoder NewEncoderFunc
                              	// DestWriter controls the destination of the log output.  Defaults to
                              	// os.Stderr.
                              	DestWriter io.Writer
                              	// DestWritter controls the destination of the log output.  Defaults to
                              	// os.Stderr.
                              	//
                              	// Deprecated: Use DestWriter instead
                              	DestWritter io.Writer
                              	// Level configures the verbosity of the logging.  Defaults to Debug when
                              	// Development is true and Info otherwise
                              	Level zapcore.LevelEnabler
                              	// StacktraceLevel is the level at and above which stacktraces will
                              	// be recorded for all messages. Defaults to Warn when Development
                              	// is true and Error otherwise
                              	StacktraceLevel zapcore.LevelEnabler
                              	// ZapOpts allows passing arbitrary zap.Options to configure on the
                              	// underlying Zap logger.
                              	ZapOpts []zap.Option
                              }

                                Options contains all possible settings

                                func (*Options) BindFlags

                                func (o *Options) BindFlags(fs *flag.FlagSet)

                                  BindFlags will parse the given flagset for zap option flags and set the log options accordingly

                                   zap-devel: Development Mode defaults(encoder=consoleEncoder,logLevel=Debug,stackTraceLevel=Warn)
                                  			  Production Mode defaults(encoder=jsonEncoder,logLevel=Info,stackTraceLevel=Error)
                                   zap-encoder: Zap log encoding (one of 'json' or 'console')
                                   zap-log-level:  Zap Level to configure the verbosity of logging. Can be one of 'debug', 'info', 'error',
                                  			       or any integer value > 0 which corresponds to custom debug levels of increasing verbosity")
                                   zap-stacktrace-level: Zap Level at and above which stacktraces are captured (one of 'info', 'error' or 'panic')
                                  

                                  type Opts

                                  type Opts func(*Options)

                                    Opts allows to manipulate Options

                                    func UseDevMode

                                    func UseDevMode(enabled bool) Opts

                                      UseDevMode sets the logger to use (or not use) development mode (more human-readable output, extra stack traces and logging information, etc). See Options.Development

                                      func UseFlagOptions

                                      func UseFlagOptions(in *Options) Opts

                                        UseFlagOptions configures the logger to use the Options set by parsing zap option flags from the CLI.

                                        opts := zap.Options{}
                                        opts.BindFlags(flag.CommandLine)
                                        flag.Parse()
                                        log := zap.New(zap.UseFlagOptions(&opts))
                                        

                                        func WriteTo

                                        func WriteTo(out io.Writer) Opts

                                          WriteTo configures the logger to write to the given io.Writer, instead of standard error. See Options.DestWriter