Make tracing interface to coalesce logging/tracing (#519)

* Define and use an interface for logging.

This allows alternative implementations to use whatever logging package
they want.

Currently the interface just mimicks what logrus already implements,
with minor modifications to not rely on logrus itself. I think the
interface is pretty solid in terms of logging implementations being able
to do what they need to.

* Make tracing interface to coalesce logging/tracing

Allows us to share data between the tracer and the logger so we can
simplify log/trace handling wher we generally want data to go both
places.

log/logrus/logrus.go

@@ -0,0 +1,34 @@
+// Package logrus implements a github.com/virtual-kubelet/virtual-kubelet/log.Logger using Logrus as a backend
+// You can use this by creating a logrus logger and calling `FromLogrus(entry)`.
+// If you want this to be the default logger for virtual-kubelet, set `log.L` to the value returned by `FromLogrus`
+package logrus
+
+import (
+	"github.com/Sirupsen/logrus"
+	"github.com/virtual-kubelet/virtual-kubelet/log"
+)
+
+// Adapter implements the `log.Logger` interface for logrus
+type Adapter struct {
+	*logrus.Entry
+}
+
+// FromLogrus creates a new `log.Logger` from the provided entry
+func FromLogrus(entry *logrus.Entry) log.Logger {
+	return &Adapter{entry}
+}
+
+// WithField adds a field to the log entry.
+func (l *Adapter) WithField(key string, val interface{}) log.Logger {
+	return FromLogrus(l.Entry.WithField(key, val))
+}
+
+// WithFields adds multiple fields to a log entry.
+func (l *Adapter) WithFields(f log.Fields) log.Logger {
+	return FromLogrus(l.Entry.WithFields(logrus.Fields(f)))
+}
+
+// WithError adds an error to the log entry
+func (l *Adapter) WithError(err error) log.Logger {
+	return FromLogrus(l.Entry.WithError(err))
+}

log/logrus/logrus_test.go

@@ -0,0 +1,16 @@
+package logrus
+
+import (
+	"testing"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/virtual-kubelet/virtual-kubelet/log"
+)
+
+func TestImplementsLoggerInterface(t *testing.T) {
+	l := FromLogrus(&logrus.Entry{})
+
+	if _, ok := l.(log.Logger); !ok {
+		t.Fatal("does not implement log.Logger interface")
+	}
+}