Update packages and add vendor directory

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

@@ -0,0 +1,199 @@
+/*
+Copyright 2018 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 log
+
+import (
+	"sync"
+
+	"github.com/go-logr/logr"
+)
+
+// loggerPromise knows how to populate a concrete logr.Logger
+// with options, given an actual base logger later on down the line.
+type loggerPromise struct {
+	logger        *DelegatingLogSink
+	childPromises []*loggerPromise
+	promisesLock  sync.Mutex
+
+	name *string
+	tags []interface{}
+}
+
+func (p *loggerPromise) WithName(l *DelegatingLogSink, name string) *loggerPromise {
+	res := &loggerPromise{
+		logger:       l,
+		name:         &name,
+		promisesLock: sync.Mutex{},
+	}
+
+	p.promisesLock.Lock()
+	defer p.promisesLock.Unlock()
+	p.childPromises = append(p.childPromises, res)
+	return res
+}
+
+// WithValues provides a new Logger with the tags appended.
+func (p *loggerPromise) WithValues(l *DelegatingLogSink, tags ...interface{}) *loggerPromise {
+	res := &loggerPromise{
+		logger:       l,
+		tags:         tags,
+		promisesLock: sync.Mutex{},
+	}
+
+	p.promisesLock.Lock()
+	defer p.promisesLock.Unlock()
+	p.childPromises = append(p.childPromises, res)
+	return res
+}
+
+// Fulfill instantiates the Logger with the provided logger.
+func (p *loggerPromise) Fulfill(parentLogSink logr.LogSink) {
+	sink := parentLogSink
+	if p.name != nil {
+		sink = sink.WithName(*p.name)
+	}
+
+	if p.tags != nil {
+		sink = sink.WithValues(p.tags...)
+	}
+
+	p.logger.lock.Lock()
+	p.logger.logger = sink
+	if withCallDepth, ok := sink.(logr.CallDepthLogSink); ok {
+		p.logger.logger = withCallDepth.WithCallDepth(1)
+	}
+	p.logger.promise = nil
+	p.logger.lock.Unlock()
+
+	for _, childPromise := range p.childPromises {
+		childPromise.Fulfill(sink)
+	}
+}
+
+// DelegatingLogSink is a logsink that delegates to another logr.LogSink.
+// If the underlying promise is not nil, it registers calls to sub-loggers with
+// the logging factory to be populated later, and returns a new delegating
+// logger.  It expects to have *some* logr.Logger set at all times (generally
+// a no-op logger before the promises are fulfilled).
+type DelegatingLogSink struct {
+	lock    sync.RWMutex
+	logger  logr.LogSink
+	promise *loggerPromise
+	info    logr.RuntimeInfo
+}
+
+// Init implements logr.LogSink.
+func (l *DelegatingLogSink) Init(info logr.RuntimeInfo) {
+	l.lock.Lock()
+	defer l.lock.Unlock()
+	l.info = info
+}
+
+// Enabled tests whether this Logger is enabled.  For example, commandline
+// flags might be used to set the logging verbosity and disable some info
+// logs.
+func (l *DelegatingLogSink) Enabled(level int) bool {
+	l.lock.RLock()
+	defer l.lock.RUnlock()
+	return l.logger.Enabled(level)
+}
+
+// Info logs a non-error message with the given key/value pairs as context.
+//
+// The msg argument should be used to add some constant description to
+// the log line.  The key/value pairs can then be used to add additional
+// variable information.  The key/value pairs should alternate string
+// keys and arbitrary values.
+func (l *DelegatingLogSink) Info(level int, msg string, keysAndValues ...interface{}) {
+	l.lock.RLock()
+	defer l.lock.RUnlock()
+	l.logger.Info(level, msg, keysAndValues...)
+}
+
+// Error logs an error, with the given message and key/value pairs as context.
+// It functions similarly to calling Info with the "error" named value, but may
+// have unique behavior, and should be preferred for logging errors (see the
+// package documentations for more information).
+//
+// The msg field should be used to add context to any underlying error,
+// while the err field should be used to attach the actual error that
+// triggered this log line, if present.
+func (l *DelegatingLogSink) Error(err error, msg string, keysAndValues ...interface{}) {
+	l.lock.RLock()
+	defer l.lock.RUnlock()
+	l.logger.Error(err, msg, keysAndValues...)
+}
+
+// WithName provides a new Logger with the name appended.
+func (l *DelegatingLogSink) WithName(name string) logr.LogSink {
+	l.lock.RLock()
+	defer l.lock.RUnlock()
+
+	if l.promise == nil {
+		sink := l.logger.WithName(name)
+		if withCallDepth, ok := sink.(logr.CallDepthLogSink); ok {
+			sink = withCallDepth.WithCallDepth(-1)
+		}
+		return sink
+	}
+
+	res := &DelegatingLogSink{logger: l.logger}
+	promise := l.promise.WithName(res, name)
+	res.promise = promise
+
+	return res
+}
+
+// WithValues provides a new Logger with the tags appended.
+func (l *DelegatingLogSink) WithValues(tags ...interface{}) logr.LogSink {
+	l.lock.RLock()
+	defer l.lock.RUnlock()
+
+	if l.promise == nil {
+		sink := l.logger.WithValues(tags...)
+		if withCallDepth, ok := sink.(logr.CallDepthLogSink); ok {
+			sink = withCallDepth.WithCallDepth(-1)
+		}
+		return sink
+	}
+
+	res := &DelegatingLogSink{logger: l.logger}
+	promise := l.promise.WithValues(res, tags...)
+	res.promise = promise
+
+	return res
+}
+
+// Fulfill switches the logger over to use the actual logger
+// provided, instead of the temporary initial one, if this method
+// has not been previously called.
+func (l *DelegatingLogSink) Fulfill(actual logr.LogSink) {
+	if l.promise != nil {
+		l.promise.Fulfill(actual)
+	}
+}
+
+// NewDelegatingLogSink constructs a new DelegatingLogSink which uses
+// the given logger before its promise is fulfilled.
+func NewDelegatingLogSink(initial logr.LogSink) *DelegatingLogSink {
+	l := &DelegatingLogSink{
+		logger:  initial,
+		promise: &loggerPromise{promisesLock: sync.Mutex{}},
+	}
+	l.promise.logger = l
+	return l
+}

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

@@ -0,0 +1,102 @@
+/*
+Copyright 2018 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 log contains utilities for fetching a new logger
+// when one is not already available.
+//
+// # The Log Handle
+//
+// This package contains a root logr.Logger Log.  It may be used to
+// get a handle to whatever the root logging implementation is.  By
+// default, no implementation exists, and the handle returns "promises"
+// to loggers.  When the implementation is set using SetLogger, these
+// "promises" will be converted over to real loggers.
+//
+// # Logr
+//
+// All logging in controller-runtime is structured, using a set of interfaces
+// defined by a package called logr
+// (https://pkg.go.dev/github.com/go-logr/logr).  The sub-package zap provides
+// helpers for setting up logr backed by Zap (go.uber.org/zap).
+package log
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/go-logr/logr"
+)
+
+// SetLogger sets a concrete logging implementation for all deferred Loggers.
+func SetLogger(l logr.Logger) {
+	loggerWasSetLock.Lock()
+	defer loggerWasSetLock.Unlock()
+
+	loggerWasSet = true
+	dlog.Fulfill(l.GetSink())
+}
+
+// It is safe to assume that if this wasn't set within the first 30 seconds of a binaries
+// lifetime, it will never get set. The DelegatingLogSink causes a high number of memory
+// allocations when not given an actual Logger, so we set a NullLogSink to avoid that.
+//
+// We need to keep the DelegatingLogSink because we have various inits() that get a logger from
+// here. They will always get executed before any code that imports controller-runtime
+// has a chance to run and hence to set an actual logger.
+func init() {
+	// Init is blocking, so start a new goroutine
+	go func() {
+		time.Sleep(30 * time.Second)
+		loggerWasSetLock.Lock()
+		defer loggerWasSetLock.Unlock()
+		if !loggerWasSet {
+			dlog.Fulfill(NullLogSink{})
+		}
+	}()
+}
+
+var (
+	loggerWasSetLock sync.Mutex
+	loggerWasSet     bool
+)
+
+// Log is the base logger used by kubebuilder.  It delegates
+// to another logr.Logger. You *must* call SetLogger to
+// get any actual logging. If SetLogger is not called within
+// the first 30 seconds of a binaries lifetime, it will get
+// set to a NullLogSink.
+var (
+	dlog = NewDelegatingLogSink(NullLogSink{})
+	Log  = logr.New(dlog)
+)
+
+// FromContext returns a logger with predefined values from a context.Context.
+func FromContext(ctx context.Context, keysAndValues ...interface{}) logr.Logger {
+	log := Log
+	if ctx != nil {
+		if logger, err := logr.FromContext(ctx); err == nil {
+			log = logger
+		}
+	}
+	return log.WithValues(keysAndValues...)
+}
+
+// IntoContext takes a context and sets the logger as one of its values.
+// Use FromContext function to retrieve the logger.
+func IntoContext(ctx context.Context, log logr.Logger) context.Context {
+	return logr.NewContext(ctx, log)
+}

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

@@ -0,0 +1,59 @@
+/*
+Copyright 2018 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 log
+
+import (
+	"github.com/go-logr/logr"
+)
+
+// NB: this is the same as the null logger logr/testing,
+// but avoids accidentally adding the testing flags to
+// all binaries.
+
+// NullLogSink is a logr.Logger that does nothing.
+type NullLogSink struct{}
+
+var _ logr.LogSink = NullLogSink{}
+
+// Init implements logr.LogSink.
+func (log NullLogSink) Init(logr.RuntimeInfo) {
+}
+
+// Info implements logr.InfoLogger.
+func (NullLogSink) Info(_ int, _ string, _ ...interface{}) {
+	// Do nothing.
+}
+
+// Enabled implements logr.InfoLogger.
+func (NullLogSink) Enabled(level int) bool {
+	return false
+}
+
+// Error implements logr.Logger.
+func (NullLogSink) Error(_ error, _ string, _ ...interface{}) {
+	// Do nothing.
+}
+
+// WithName implements logr.Logger.
+func (log NullLogSink) WithName(_ string) logr.LogSink {
+	return log
+}
+
+// WithValues implements logr.Logger.
+func (log NullLogSink) WithValues(_ ...interface{}) logr.LogSink {
+	return log
+}

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

@@ -0,0 +1,76 @@
+/*
+Copyright 2018 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 log
+
+import (
+	"sync"
+
+	"github.com/go-logr/logr"
+)
+
+// KubeAPIWarningLoggerOptions controls the behavior
+// of a rest.WarningHandler constructed using NewKubeAPIWarningLogger().
+type KubeAPIWarningLoggerOptions struct {
+	// Deduplicate indicates a given warning message should only be written once.
+	// Setting this to true in a long-running process handling many warnings can
+	// result in increased memory use.
+	Deduplicate bool
+}
+
+// KubeAPIWarningLogger is a wrapper around
+// a provided logr.Logger that implements the
+// rest.WarningHandler interface.
+type KubeAPIWarningLogger struct {
+	// logger is used to log responses with the warning header
+	logger logr.Logger
+	// opts contain options controlling warning output
+	opts KubeAPIWarningLoggerOptions
+	// writtenLock gurads written
+	writtenLock sync.Mutex
+	// used to keep track of already logged messages
+	// and help in de-duplication.
+	written map[string]struct{}
+}
+
+// HandleWarningHeader handles logging for responses from API server that are
+// warnings with code being 299 and uses a logr.Logger for its logging purposes.
+func (l *KubeAPIWarningLogger) HandleWarningHeader(code int, agent string, message string) {
+	if code != 299 || len(message) == 0 {
+		return
+	}
+
+	if l.opts.Deduplicate {
+		l.writtenLock.Lock()
+		defer l.writtenLock.Unlock()
+
+		if _, alreadyLogged := l.written[message]; alreadyLogged {
+			return
+		}
+		l.written[message] = struct{}{}
+	}
+	l.logger.Info(message)
+}
+
+// NewKubeAPIWarningLogger returns an implementation of rest.WarningHandler that logs warnings
+// with code = 299 to the provided logr.Logger.
+func NewKubeAPIWarningLogger(l logr.Logger, opts KubeAPIWarningLoggerOptions) *KubeAPIWarningLogger {
+	h := &KubeAPIWarningLogger{logger: l, opts: opts}
+	if opts.Deduplicate {
+		h.written = map[string]struct{}{}
+	}
+	return h
+}

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

@@ -0,0 +1,168 @@
+/*
+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,
+}
+
+var stackLevelStrings = map[string]zapcore.Level{
+	"info":  zap.InfoLevel,
+	"error": zap.ErrorLevel,
+	"panic": zap.PanicLevel,
+}
+
+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"
+}
+
+type timeEncodingFlag struct {
+	setFunc func(zapcore.TimeEncoder)
+	value   string
+}
+
+var _ flag.Value = &timeEncodingFlag{}
+
+func (ev *timeEncodingFlag) String() string {
+	return ev.value
+}
+
+func (ev *timeEncodingFlag) Type() string {
+	return "time-encoding"
+}
+
+func (ev *timeEncodingFlag) Set(flagValue string) error {
+	val := strings.ToLower(flagValue)
+	switch val {
+	case "rfc3339nano":
+		ev.setFunc(zapcore.RFC3339NanoTimeEncoder)
+	case "rfc3339":
+		ev.setFunc(zapcore.RFC3339TimeEncoder)
+	case "iso8601":
+		ev.setFunc(zapcore.ISO8601TimeEncoder)
+	case "millis":
+		ev.setFunc(zapcore.EpochMillisTimeEncoder)
+	case "nanos":
+		ev.setFunc(zapcore.EpochNanosTimeEncoder)
+	case "epoch":
+		ev.setFunc(zapcore.EpochTimeEncoder)
+	default:
+		return fmt.Errorf("invalid time-encoding value \"%s\"", flagValue)
+	}
+
+	ev.value = flagValue
+	return nil
+}

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

@@ -0,0 +1,133 @@
+/*
+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"
+	"reflect"
+
+	"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.
+
+	if reflect.ValueOf(w.obj).IsNil() {
+		return fmt.Errorf("got nil for runtime.Object")
+	}
+
+	if gvk := w.obj.GetObjectKind().GroupVersionKind(); 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)
+	}
+
+	if ns := objMeta.GetNamespace(); 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,311 @@
+/*
+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.DestWriter.
+func WriteTo(out io.Writer) Opts {
+	return func(o *Options) {
+		o.DestWriter = 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 Options.Level, which configures the the minimum enabled logging level e.g Debug, Info.
+// A zap log level should be multiplied by -1 to get the logr verbosity.
+// For example, to get logr verbosity of 3, pass zapcore.Level(-3) to this Opts.
+// See https://pkg.go.dev/github.com/go-logr/zapr for how zap level relates to logr verbosity.
+func Level(level zapcore.LevelEnabler) func(o *Options) {
+	return func(o *Options) {
+		o.Level = level
+	}
+}
+
+// StacktraceLevel sets Options.StacktraceLevel, which configures the logger to record a stack trace
+// for all messages at or above a given level.
+// See the Level Opts for the relationship of zap log level to logr verbosity.
+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://pkg.go.dev/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.
+	// A zap log level should be multiplied by -1 to get the logr verbosity.
+	// For example, to get logr verbosity of 3, set this field to zapcore.Level(-3).
+	// See https://pkg.go.dev/github.com/go-logr/zapr for how zap level relates to logr verbosity.
+	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.
+	// See Level for the relationship of zap log level to logr verbosity.
+	StacktraceLevel zapcore.LevelEnabler
+	// ZapOpts allows passing arbitrary zap.Options to configure on the
+	// underlying Zap logger.
+	ZapOpts []zap.Option
+	// TimeEncoder specifies the encoder for the timestamps in log messages.
+	// Defaults to EpochTimeEncoder as this is the default in Zap currently.
+	TimeEncoder zapcore.TimeEncoder
+}
+
+// addDefaults adds defaults to the Options.
+func (o *Options) addDefaults() {
+	if o.DestWriter == nil && o.DestWritter == nil {
+		o.DestWriter = os.Stderr
+	} else if o.DestWriter == nil && o.DestWritter != nil {
+		// while misspelled DestWritter is deprecated but still not removed
+		o.DestWriter = o.DestWritter
+	}
+
+	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.NewSamplerWithOptions(core, time.Second, 100, 100)
+				}))
+		}
+	}
+
+	if o.TimeEncoder == nil {
+		o.TimeEncoder = zapcore.EpochTimeEncoder
+	}
+	f := func(ecfg *zapcore.EncoderConfig) {
+		ecfg.EncodeTime = o.TimeEncoder
+	}
+	// prepend instead of append it in case someone adds a time encoder option in it
+	o.EncoderConfigOptions = append([]EncoderConfigOption{f}, o.EncoderConfigOptions...)
+
+	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.DestWriter)
+
+	o.ZapOpts = append(o.ZapOpts, 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', 'error' or 'panic')
+//   - zap-time-encoding: Zap time encoding (one of 'epoch', 'millis', 'nano', 'iso8601', 'rfc3339' or 'rfc3339nano'),
+//     Defaults to 'epoch'.
+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', 'panic').")
+
+	// Set the time encoding
+	var timeEncoderVal timeEncodingFlag
+	timeEncoderVal.setFunc = func(fromFlag zapcore.TimeEncoder) {
+		o.TimeEncoder = fromFlag
+	}
+	fs.Var(&timeEncoderVal, "zap-time-encoding", "Zap time encoding (one of 'epoch', 'millis', 'nano', 'iso8601', 'rfc3339' or 'rfc3339nano'). Defaults to 'epoch'.")
+}
+
+// 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
+	}
+}