Initial v1.0.0 commit

vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/flags.go

@@ -0,0 +1,131 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package zap contains helpers for setting up a new logr.Logger instance
+// using the Zap logging framework.
+package zap
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+var levelStrings = map[string]zapcore.Level{
+	"debug": zap.DebugLevel,
+	"info":  zap.InfoLevel,
+	"error": zap.ErrorLevel,
+}
+
+// TODO Add level to disable stacktraces.
+// https://github.com/kubernetes-sigs/controller-runtime/issues/1035
+var stackLevelStrings = map[string]zapcore.Level{
+	"info":  zap.InfoLevel,
+	"error": zap.ErrorLevel,
+}
+
+type encoderFlag struct {
+	setFunc func(NewEncoderFunc)
+	value   string
+}
+
+var _ flag.Value = &encoderFlag{}
+
+func (ev *encoderFlag) String() string {
+	return ev.value
+}
+
+func (ev *encoderFlag) Type() string {
+	return "encoder"
+}
+
+func (ev *encoderFlag) Set(flagValue string) error {
+	val := strings.ToLower(flagValue)
+	switch val {
+	case "json":
+		ev.setFunc(newJSONEncoder)
+	case "console":
+		ev.setFunc(newConsoleEncoder)
+	default:
+		return fmt.Errorf("invalid encoder value \"%s\"", flagValue)
+	}
+	ev.value = flagValue
+	return nil
+}
+
+type levelFlag struct {
+	setFunc func(zapcore.LevelEnabler)
+	value   string
+}
+
+var _ flag.Value = &levelFlag{}
+
+func (ev *levelFlag) Set(flagValue string) error {
+	level, validLevel := levelStrings[strings.ToLower(flagValue)]
+	if !validLevel {
+		logLevel, err := strconv.Atoi(flagValue)
+		if err != nil {
+			return fmt.Errorf("invalid log level \"%s\"", flagValue)
+		}
+		if logLevel > 0 {
+			intLevel := -1 * logLevel
+			ev.setFunc(zap.NewAtomicLevelAt(zapcore.Level(int8(intLevel))))
+		} else {
+			return fmt.Errorf("invalid log level \"%s\"", flagValue)
+		}
+	} else {
+		ev.setFunc(zap.NewAtomicLevelAt(level))
+	}
+	ev.value = flagValue
+	return nil
+}
+
+func (ev *levelFlag) String() string {
+	return ev.value
+}
+
+func (ev *levelFlag) Type() string {
+	return "level"
+}
+
+type stackTraceFlag struct {
+	setFunc func(zapcore.LevelEnabler)
+	value   string
+}
+
+var _ flag.Value = &stackTraceFlag{}
+
+func (ev *stackTraceFlag) Set(flagValue string) error {
+	level, validLevel := stackLevelStrings[strings.ToLower(flagValue)]
+	if !validLevel {
+		return fmt.Errorf("invalid stacktrace level \"%s\"", flagValue)
+	}
+	ev.setFunc(zap.NewAtomicLevelAt(level))
+	ev.value = flagValue
+	return nil
+}
+
+func (ev *stackTraceFlag) String() string {
+	return ev.value
+}
+
+func (ev *stackTraceFlag) Type() string {
+	return "level"
+}

vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/kube_helpers.go

@@ -0,0 +1,129 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package zap
+
+import (
+	"fmt"
+
+	"go.uber.org/zap/buffer"
+	"go.uber.org/zap/zapcore"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+// 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.
+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
+}
+
+// namespacedNameWrapper is a zapcore.ObjectMarshaler for Kubernetes NamespacedName
+type namespacedNameWrapper struct {
+	types.NamespacedName
+}
+
+func (w namespacedNameWrapper) MarshalLogObject(enc zapcore.ObjectEncoder) error {
+	if w.Namespace != "" {
+		enc.AddString("namespace", w.Namespace)
+	}
+
+	enc.AddString("name", w.Name)
+
+	return nil
+}
+
+// kubeObjectWrapper is a zapcore.ObjectMarshaler for Kubernetes objects.
+type kubeObjectWrapper struct {
+	obj runtime.Object
+}
+
+// MarshalLogObject implements zapcore.ObjectMarshaler
+func (w kubeObjectWrapper) MarshalLogObject(enc zapcore.ObjectEncoder) error {
+	// TODO(directxman12): log kind and apiversion if not set explicitly (common case)
+	// -- needs an a scheme to convert to the GVK.
+	gvk := w.obj.GetObjectKind().GroupVersionKind()
+	if gvk.Version != "" {
+		enc.AddString("apiVersion", gvk.GroupVersion().String())
+		enc.AddString("kind", gvk.Kind)
+	}
+
+	objMeta, err := meta.Accessor(w.obj)
+	if err != nil {
+		return fmt.Errorf("got runtime.Object without object metadata: %v", w.obj)
+	}
+
+	ns := objMeta.GetNamespace()
+	if ns != "" {
+		enc.AddString("namespace", ns)
+	}
+	enc.AddString("name", objMeta.GetName())
+
+	return nil
+}
+
+// NB(directxman12): can't just override AddReflected, since the encoder calls AddReflected on itself directly
+
+// Clone implements zapcore.Encoder
+func (k *KubeAwareEncoder) Clone() zapcore.Encoder {
+	return &KubeAwareEncoder{
+		Encoder: k.Encoder.Clone(),
+	}
+}
+
+// EncodeEntry implements zapcore.Encoder
+func (k *KubeAwareEncoder) EncodeEntry(entry zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) {
+	if k.Verbose {
+		// Kubernetes objects implement fmt.Stringer, so if we
+		// want verbose output, just delegate to that.
+		return k.Encoder.EncodeEntry(entry, fields)
+	}
+
+	for i, field := range fields {
+		// intercept stringer fields that happen to be Kubernetes runtime.Object or
+		// types.NamespacedName values (Kubernetes runtime.Objects commonly
+		// implement String, apparently).
+		// *unstructured.Unstructured does NOT implement fmt.Striger interface.
+		// We have handle it specially.
+		if field.Type == zapcore.StringerType || field.Type == zapcore.ReflectType {
+			switch val := field.Interface.(type) {
+			case runtime.Object:
+				fields[i] = zapcore.Field{
+					Type:      zapcore.ObjectMarshalerType,
+					Key:       field.Key,
+					Interface: kubeObjectWrapper{obj: val},
+				}
+			case types.NamespacedName:
+				fields[i] = zapcore.Field{
+					Type:      zapcore.ObjectMarshalerType,
+					Key:       field.Key,
+					Interface: namespacedNameWrapper{NamespacedName: val},
+				}
+			}
+		}
+	}
+
+	return k.Encoder.EncodeEntry(entry, fields)
+}

vendor/sigs.k8s.io/controller-runtime/pkg/log/zap/zap.go

@@ -0,0 +1,275 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package zap contains helpers for setting up a new logr.Logger instance
+// using the Zap logging framework.
+package zap
+
+import (
+	"flag"
+	"io"
+	"os"
+	"time"
+
+	"github.com/go-logr/logr"
+	"github.com/go-logr/zapr"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// EncoderConfigOption is a function that can modify a `zapcore.EncoderConfig`.
+type EncoderConfigOption func(*zapcore.EncoderConfig)
+
+// NewEncoderFunc is a function that creates an Encoder using the provided EncoderConfigOptions.
+type NewEncoderFunc func(...EncoderConfigOption) zapcore.Encoder
+
+// New returns a brand new Logger configured with Opts. It
+// uses KubeAwareEncoder which adds Type information and
+// Namespace/Name to the log.
+func New(opts ...Opts) logr.Logger {
+	return zapr.NewLogger(NewRaw(opts...))
+}
+
+// Opts allows to manipulate Options
+type Opts func(*Options)
+
+// 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 UseDevMode(enabled bool) Opts {
+	return func(o *Options) {
+		o.Development = enabled
+	}
+}
+
+// WriteTo configures the logger to write to the given io.Writer, instead of standard error.
+// See Options.DestWritter
+func WriteTo(out io.Writer) Opts {
+	return func(o *Options) {
+		o.DestWritter = out
+	}
+}
+
+// Encoder configures how the logger will encode the output e.g JSON or console.
+// See Options.Encoder
+func Encoder(encoder zapcore.Encoder) func(o *Options) {
+	return func(o *Options) {
+		o.Encoder = encoder
+	}
+}
+
+// JSONEncoder configures the logger to use a JSON Encoder
+func JSONEncoder(opts ...EncoderConfigOption) func(o *Options) {
+	return func(o *Options) {
+		o.Encoder = newJSONEncoder(opts...)
+	}
+}
+
+func newJSONEncoder(opts ...EncoderConfigOption) zapcore.Encoder {
+	encoderConfig := zap.NewProductionEncoderConfig()
+	for _, opt := range opts {
+		opt(&encoderConfig)
+	}
+	return zapcore.NewJSONEncoder(encoderConfig)
+}
+
+// ConsoleEncoder configures the logger to use a Console encoder
+func ConsoleEncoder(opts ...EncoderConfigOption) func(o *Options) {
+	return func(o *Options) {
+		o.Encoder = newConsoleEncoder(opts...)
+	}
+}
+
+func newConsoleEncoder(opts ...EncoderConfigOption) zapcore.Encoder {
+	encoderConfig := zap.NewDevelopmentEncoderConfig()
+	for _, opt := range opts {
+		opt(&encoderConfig)
+	}
+	return zapcore.NewConsoleEncoder(encoderConfig)
+}
+
+// Level sets the the minimum enabled logging level e.g Debug, Info
+// See Options.Level
+func Level(level zapcore.LevelEnabler) func(o *Options) {
+	return func(o *Options) {
+		o.Level = level
+	}
+}
+
+// StacktraceLevel configures the logger to record a stack trace for all messages at
+// or above a given level.
+// See Options.StacktraceLevel
+func StacktraceLevel(stacktraceLevel zapcore.LevelEnabler) func(o *Options) {
+	return func(o *Options) {
+		o.StacktraceLevel = stacktraceLevel
+	}
+}
+
+// RawZapOpts allows appending arbitrary zap.Options to configure the underlying zap logger.
+// See Options.ZapOpts
+func RawZapOpts(zapOpts ...zap.Option) func(o *Options) {
+	return func(o *Options) {
+		o.ZapOpts = append(o.ZapOpts, zapOpts...)
+	}
+}
+
+// Options contains all possible settings
+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
+	// DestWritter controls the destination of the log output.  Defaults to
+	// os.Stderr.
+	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
+}
+
+// addDefaults adds defaults to the Options
+func (o *Options) addDefaults() {
+	if o.DestWritter == nil {
+		o.DestWritter = os.Stderr
+	}
+
+	if o.Development {
+		if o.NewEncoder == nil {
+			o.NewEncoder = newConsoleEncoder
+		}
+		if o.Level == nil {
+			lvl := zap.NewAtomicLevelAt(zap.DebugLevel)
+			o.Level = &lvl
+		}
+		if o.StacktraceLevel == nil {
+			lvl := zap.NewAtomicLevelAt(zap.WarnLevel)
+			o.StacktraceLevel = &lvl
+		}
+		o.ZapOpts = append(o.ZapOpts, zap.Development())
+
+	} else {
+		if o.NewEncoder == nil {
+			o.NewEncoder = newJSONEncoder
+		}
+		if o.Level == nil {
+			lvl := zap.NewAtomicLevelAt(zap.InfoLevel)
+			o.Level = &lvl
+		}
+		if o.StacktraceLevel == nil {
+			lvl := zap.NewAtomicLevelAt(zap.ErrorLevel)
+			o.StacktraceLevel = &lvl
+		}
+		// Disable sampling for increased Debug levels. Otherwise, this will
+		// cause index out of bounds errors in the sampling code.
+		if !o.Level.Enabled(zapcore.Level(-2)) {
+			o.ZapOpts = append(o.ZapOpts,
+				zap.WrapCore(func(core zapcore.Core) zapcore.Core {
+					return zapcore.NewSampler(core, time.Second, 100, 100)
+				}))
+		}
+	}
+	if o.Encoder == nil {
+		o.Encoder = o.NewEncoder(o.EncoderConfigOptions...)
+	}
+	o.ZapOpts = append(o.ZapOpts, zap.AddStacktrace(o.StacktraceLevel))
+}
+
+// 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 NewRaw(opts ...Opts) *zap.Logger {
+	o := &Options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+	o.addDefaults()
+
+	// this basically mimics New<type>Config, but with a custom sink
+	sink := zapcore.AddSync(o.DestWritter)
+
+	o.ZapOpts = append(o.ZapOpts, zap.AddCallerSkip(1), zap.ErrorOutput(sink))
+	log := zap.New(zapcore.NewCore(&KubeAwareEncoder{Encoder: o.Encoder, Verbose: o.Development}, sink, o.Level))
+	log = log.WithOptions(o.ZapOpts...)
+	return log
+}
+
+// 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' or 'error')
+func (o *Options) BindFlags(fs *flag.FlagSet) {
+
+	// Set Development mode value
+	fs.BoolVar(&o.Development, "zap-devel", o.Development,
+		"Development Mode defaults(encoder=consoleEncoder,logLevel=Debug,stackTraceLevel=Warn). "+
+			"Production Mode defaults(encoder=jsonEncoder,logLevel=Info,stackTraceLevel=Error)")
+
+	// Set Encoder value
+	var encVal encoderFlag
+	encVal.setFunc = func(fromFlag NewEncoderFunc) {
+		o.NewEncoder = fromFlag
+	}
+	fs.Var(&encVal, "zap-encoder", "Zap log encoding (one of 'json' or 'console')")
+
+	// Set the Log Level
+	var levelVal levelFlag
+	levelVal.setFunc = func(fromFlag zapcore.LevelEnabler) {
+		o.Level = fromFlag
+	}
+	fs.Var(&levelVal, "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")
+
+	// Set the StrackTrace Level
+	var stackVal stackTraceFlag
+	stackVal.setFunc = func(fromFlag zapcore.LevelEnabler) {
+		o.StacktraceLevel = fromFlag
+	}
+	fs.Var(&stackVal, "zap-stacktrace-level",
+		"Zap Level at and above which stacktraces are captured (one of 'info', 'error').")
+}
+
+// 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 UseFlagOptions(in *Options) Opts {
+	return func(o *Options) {
+		*o = *in
+	}
+}