diff --git a/Gopkg.lock b/Gopkg.lock index df0e6dd62b..834d4eb408 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -1091,9 +1091,12 @@ revision = "0689ccc1d7d65d9dd1bedcc3b0b1ed7df91ba266" [[projects]] - digest = "1:72fd56341405f53c745377e0ebc4abeff87f1a048e0eea6568a20212650f5a82" + digest = "1:ed455ccc8731bfd9299cbdaebd7a96da8097f5399f15ee4ec5d3ea3bcdff9f91" name = "k8s.io/klog" - packages = ["."] + packages = [ + ".", + "klogr", + ] pruneopts = "UT" revision = "71442cd4037d612096940ceb0f3fec3f7fff66e0" version = "v0.2.0" @@ -1269,6 +1272,7 @@ "github.com/aws/aws-sdk-go/service/sts/stsiface", "github.com/awslabs/goformation/cloudformation", "github.com/emicklei/go-restful", + "github.com/go-logr/logr", "github.com/golang/mock/gomock", "github.com/onsi/ginkgo", "github.com/onsi/ginkgo/config", @@ -1300,6 +1304,7 @@ "k8s.io/cluster-bootstrap/token/util", "k8s.io/code-generator/cmd/deepcopy-gen", "k8s.io/klog", + "k8s.io/klog/klogr", "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta1", "k8s.io/kubernetes/cmd/kubeadm/app/util", "sigs.k8s.io/cluster-api/cmd/clusterctl/cmd", diff --git a/cmd/manager/main.go b/cmd/manager/main.go index 2e8137abad..9380bd3159 100644 --- a/cmd/manager/main.go +++ b/cmd/manager/main.go @@ -70,7 +70,8 @@ func main() { // Initialize cluster actuator. clusterActuator := cluster.NewActuator(cluster.ActuatorParams{ - Client: cs.ClusterV1alpha1(), + Client: cs.ClusterV1alpha1(), + LoggingContext: "[cluster actuator]", }) // Initialize machine actuator. diff --git a/pkg/cloud/aws/actuators/cluster/BUILD.bazel b/pkg/cloud/aws/actuators/cluster/BUILD.bazel index 16ea6c04e7..78d7763874 100644 --- a/pkg/cloud/aws/actuators/cluster/BUILD.bazel +++ b/pkg/cloud/aws/actuators/cluster/BUILD.bazel @@ -11,8 +11,10 @@ go_library( "//pkg/cloud/aws/services/ec2:go_default_library", "//pkg/cloud/aws/services/elb:go_default_library", "//pkg/deployer:go_default_library", + "//vendor/github.com/go-logr/logr:go_default_library", "//vendor/github.com/pkg/errors:go_default_library", "//vendor/k8s.io/klog:go_default_library", + "//vendor/k8s.io/klog/klogr:go_default_library", "//vendor/sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha1:go_default_library", "//vendor/sigs.k8s.io/cluster-api/pkg/client/clientset_generated/clientset/typed/cluster/v1alpha1:go_default_library", "//vendor/sigs.k8s.io/cluster-api/pkg/controller/error:go_default_library", diff --git a/pkg/cloud/aws/actuators/cluster/actuator.go b/pkg/cloud/aws/actuators/cluster/actuator.go index 7c7813cd5f..956bf749aa 100644 --- a/pkg/cloud/aws/actuators/cluster/actuator.go +++ b/pkg/cloud/aws/actuators/cluster/actuator.go @@ -17,8 +17,10 @@ limitations under the License. package cluster import ( + "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/klog" + "k8s.io/klog/klogr" "sigs.k8s.io/cluster-api-provider-aws/pkg/cloud/aws/actuators" "sigs.k8s.io/cluster-api-provider-aws/pkg/cloud/aws/services/certificates" "sigs.k8s.io/cluster-api-provider-aws/pkg/cloud/aws/services/ec2" @@ -37,11 +39,13 @@ type Actuator struct { *deployer.Deployer client client.ClusterV1alpha1Interface + log logr.Logger } // ActuatorParams holds parameter information for Actuator type ActuatorParams struct { - Client client.ClusterV1alpha1Interface + Client client.ClusterV1alpha1Interface + LoggingContext string } // NewActuator creates a new Actuator @@ -49,6 +53,7 @@ func NewActuator(params ActuatorParams) *Actuator { return &Actuator{ Deployer: deployer.New(deployer.Params{ScopeGetter: actuators.DefaultScopeGetter}), client: params.Client, + log: klogr.New().WithName(params.LoggingContext), } } diff --git a/vendor/k8s.io/klog/klogr/BUILD.bazel b/vendor/k8s.io/klog/klogr/BUILD.bazel new file mode 100644 index 0000000000..a5ece4bb9d --- /dev/null +++ b/vendor/k8s.io/klog/klogr/BUILD.bazel @@ -0,0 +1,13 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library") + +go_library( + name = "go_default_library", + srcs = ["klogr.go"], + importmap = "sigs.k8s.io/cluster-api-provider-aws/vendor/k8s.io/klog/klogr", + importpath = "k8s.io/klog/klogr", + visibility = ["//visibility:public"], + deps = [ + "//vendor/github.com/go-logr/logr:go_default_library", + "//vendor/k8s.io/klog:go_default_library", + ], +) diff --git a/vendor/k8s.io/klog/klogr/README.md b/vendor/k8s.io/klog/klogr/README.md new file mode 100644 index 0000000000..4f5618d7f0 --- /dev/null +++ b/vendor/k8s.io/klog/klogr/README.md @@ -0,0 +1,8 @@ +# Minimal Go logging using klog + +This package implements the [logr interface](github.com/go-logr/logr) +in terms of Kubernetes' [klog](https://github.com/kubernetes/klog). This +provides a relatively minimalist API to logging in Go, backed by a well-proven +implementation. + +This is a BETA grade implementation. diff --git a/vendor/k8s.io/klog/klogr/klogr.go b/vendor/k8s.io/klog/klogr/klogr.go new file mode 100644 index 0000000000..e09e82212e --- /dev/null +++ b/vendor/k8s.io/klog/klogr/klogr.go @@ -0,0 +1,147 @@ +// Package klogr implements github.com/go-logr/logr.Logger in terms of +// k8s.io/klog. +package klogr + +import ( + "bytes" + "encoding/json" + "fmt" + "runtime" + "sort" + + "github.com/go-logr/logr" + "k8s.io/klog" +) + +// New returns a logr.Logger which is implemented by klog. +func New() logr.Logger { + return klogger{ + level: 0, + prefix: "", + values: nil, + } +} + +type klogger struct { + level int + prefix string + values []interface{} +} + +func (l klogger) clone() klogger { + return klogger{ + level: l.level, + prefix: l.prefix, + values: copySlice(l.values), + } +} + +func copySlice(in []interface{}) []interface{} { + out := make([]interface{}, len(in)) + copy(out, in) + return out +} + +// Magic string for intermediate frames that we should ignore. +const autogeneratedFrameName = "" + +// Discover how many frames we need to climb to find the caller. This approach +// was suggested by Ian Lance Taylor of the Go team, so it *should* be safe +// enough (famous last words). +func framesToCaller() int { + // 1 is the immediate caller. 3 should be too many. + for i := 1; i < 3; i++ { + _, file, _, _ := runtime.Caller(i + 1) // +1 for this function's frame + if file != autogeneratedFrameName { + return i + } + } + return 1 // something went wrong, this is safe +} + +func flatten(kvList ...interface{}) string { + keys := make([]string, 0, len(kvList)) + vals := make(map[string]interface{}, len(kvList)) + for i := 0; i < len(kvList); i += 2 { + k, ok := kvList[i].(string) + if !ok { + panic(fmt.Sprintf("key is not a string: %s", pretty(kvList[i]))) + } + var v interface{} + if i+1 < len(kvList) { + v = kvList[i+1] + } + keys = append(keys, k) + vals[k] = v + } + sort.Strings(keys) + buf := bytes.Buffer{} + for i, k := range keys { + v := vals[k] + if i > 0 { + buf.WriteRune(' ') + } + buf.WriteString(pretty(k)) + buf.WriteString("=") + buf.WriteString(pretty(v)) + } + return buf.String() +} + +func pretty(value interface{}) string { + jb, _ := json.Marshal(value) + return string(jb) +} + +func (l klogger) Info(msg string, kvList ...interface{}) { + if l.Enabled() { + lvlStr := flatten("level", l.level) + msgStr := flatten("msg", msg) + fixedStr := flatten(l.values...) + userStr := flatten(kvList...) + klog.InfoDepth(framesToCaller(), l.prefix, " ", lvlStr, " ", msgStr, " ", fixedStr, " ", userStr) + } +} + +func (l klogger) Enabled() bool { + return bool(klog.V(klog.Level(l.level))) +} + +func (l klogger) Error(err error, msg string, kvList ...interface{}) { + msgStr := flatten("msg", msg) + var loggableErr interface{} + if err != nil { + loggableErr = err.Error() + } + errStr := flatten("error", loggableErr) + fixedStr := flatten(l.values...) + userStr := flatten(kvList...) + klog.ErrorDepth(framesToCaller(), l.prefix, " ", msgStr, " ", errStr, " ", fixedStr, " ", userStr) +} + +func (l klogger) V(level int) logr.InfoLogger { + new := l.clone() + new.level = level + return new +} + +// WithName returns a new logr.Logger with the specified name appended. klogr +// uses '/' characters to separate name elements. Callers should not pass '/' +// in the provided name string, but this library does not actually enforce that. +func (l klogger) WithName(name string) logr.Logger { + new := l.clone() + if len(l.prefix) > 0 { + new.prefix = l.prefix + "/" + } + new.prefix += name + return new +} + +func (l klogger) WithValues(kvList ...interface{}) logr.Logger { + new := l.clone() + new.values = append(new.values, kvList...) + return new +} + +var _ logr.Logger = klogger{} +var _ logr.InfoLogger = klogger{}