From d89ba3f81331ec1e9d76f21aa2fb356e45a09983 Mon Sep 17 00:00:00 2001
From: Adam Reese <adam@reese.io>
Date: Fri, 19 May 2017 11:18:02 -0700
Subject: [PATCH] replace interface with function

---
 cmd/tiller/tiller.go              | 31 ++++++------
 cmd/tiller/trace.go               |  5 +-
 pkg/kube/client.go                | 48 +++++++++----------
 pkg/kube/client_test.go           |  9 ++--
 pkg/logger/doc.go                 | 18 -------
 pkg/logger/logger.go              | 36 --------------
 pkg/storage/driver/cfgmaps.go     | 32 +++++++------
 pkg/storage/storage.go            | 29 ++++++------
 pkg/tiller/release_server.go      | 79 +++++++++++++++----------------
 pkg/tiller/release_server_test.go |  3 +-
 10 files changed, 116 insertions(+), 174 deletions(-)
 delete mode 100644 pkg/logger/doc.go
 delete mode 100644 pkg/logger/logger.go

diff --git a/cmd/tiller/tiller.go b/cmd/tiller/tiller.go
index 797f7d57d..6abd35ec9 100644
--- a/cmd/tiller/tiller.go
+++ b/cmd/tiller/tiller.go
@@ -70,6 +70,8 @@ var rootServer *grpc.Server
 // Any changes to env should be done before rootServer.Serve() is called.
 var env = environment.New()
 
+var logger *log.Logger
+
 var (
 	grpcAddr             = ":44134"
 	probeAddr            = ":44135"
@@ -111,6 +113,7 @@ func initLog() {
 	if enableTracing {
 		log.SetFlags(log.Lshortfile)
 	}
+	logger = newLogger("main")
 }
 
 func main() {
@@ -126,7 +129,7 @@ func main() {
 	addFlags(root.Flags())
 
 	if err := root.Execute(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -140,7 +143,7 @@ func newLogger(prefix string) *log.Logger {
 func start(c *cobra.Command, args []string) {
 	clientset, err := kube.New(nil).ClientSet()
 	if err != nil {
-		log.Fatalf("Cannot initialize Kubernetes connection: %s", err)
+		logger.Fatalf("Cannot initialize Kubernetes connection: %s", err)
 	}
 
 	switch store {
@@ -148,14 +151,14 @@ func start(c *cobra.Command, args []string) {
 		env.Releases = storage.Init(driver.NewMemory())
 	case storageConfigMap:
 		cfgmaps := driver.NewConfigMaps(clientset.Core().ConfigMaps(namespace()))
-		cfgmaps.Logger = newLogger("storage/driver")
+		cfgmaps.Log = newLogger("storage/driver").Printf
 
 		env.Releases = storage.Init(cfgmaps)
-		env.Releases.Logger = newLogger("storage")
+		env.Releases.Log = newLogger("storage").Printf
 	}
 
 	kubeClient := kube.New(nil)
-	kubeClient.Logger = newLogger("kube")
+	kubeClient.Log = newLogger("kube").Printf
 	env.KubeClient = kubeClient
 
 	if tlsEnable || tlsVerify {
@@ -169,7 +172,7 @@ func start(c *cobra.Command, args []string) {
 	if tlsEnable || tlsVerify {
 		cfg, err := tlsutil.ServerConfig(tlsOptions())
 		if err != nil {
-			log.Fatalf("Could not create server TLS configuration: %v", err)
+			logger.Fatalf("Could not create server TLS configuration: %v", err)
 		}
 		opts = append(opts, grpc.Creds(credentials.NewTLS(cfg)))
 	}
@@ -178,13 +181,13 @@ func start(c *cobra.Command, args []string) {
 
 	lstn, err := net.Listen("tcp", grpcAddr)
 	if err != nil {
-		log.Fatalf("Server died: %s", err)
+		logger.Fatalf("Server died: %s", err)
 	}
 
-	log.Printf("Starting Tiller %s (tls=%t)", version.GetVersion(), tlsEnable || tlsVerify)
-	log.Printf("GRPC listening on %s", grpcAddr)
-	log.Printf("Probes listening on %s", probeAddr)
-	log.Printf("Storage driver is %s", env.Releases.Name())
+	logger.Printf("Starting Tiller %s (tls=%t)", version.GetVersion(), tlsEnable || tlsVerify)
+	logger.Printf("GRPC listening on %s", grpcAddr)
+	logger.Printf("Probes listening on %s", probeAddr)
+	logger.Printf("Storage driver is %s", env.Releases.Name())
 
 	if enableTracing {
 		startTracing(traceAddr)
@@ -194,7 +197,7 @@ func start(c *cobra.Command, args []string) {
 	probeErrCh := make(chan error)
 	go func() {
 		svc := tiller.NewReleaseServer(env, clientset, remoteReleaseModules)
-		svc.Logger = newLogger("tiller")
+		svc.Log = newLogger("tiller").Printf
 		services.RegisterReleaseServiceServer(rootServer, svc)
 		if err := rootServer.Serve(lstn); err != nil {
 			srvErrCh <- err
@@ -215,9 +218,9 @@ func start(c *cobra.Command, args []string) {
 
 	select {
 	case err := <-srvErrCh:
-		log.Fatalf("Server died: %s", err)
+		logger.Fatalf("Server died: %s", err)
 	case err := <-probeErrCh:
-		log.Printf("Probes server died: %s", err)
+		logger.Printf("Probes server died: %s", err)
 	}
 }
 
diff --git a/cmd/tiller/trace.go b/cmd/tiller/trace.go
index 1aa15e019..71d7e8f72 100644
--- a/cmd/tiller/trace.go
+++ b/cmd/tiller/trace.go
@@ -17,7 +17,6 @@ limitations under the License.
 package main // import "k8s.io/helm/cmd/tiller"
 
 import (
-	"log"
 	"net/http"
 
 	_ "net/http/pprof"
@@ -26,7 +25,7 @@ import (
 )
 
 func startTracing(addr string) {
-	log.Printf("Tracing server is listening on %s\n", addr)
+	logger.Printf("Tracing server is listening on %s\n", addr)
 	grpc.EnableTracing = true
 
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
@@ -40,7 +39,7 @@ func startTracing(addr string) {
 
 	go func() {
 		if err := http.ListenAndServe(addr, nil); err != nil {
-			log.Printf("tracing error: %s", err)
+			logger.Printf("tracing error: %s", err)
 		}
 	}()
 }
diff --git a/pkg/kube/client.go b/pkg/kube/client.go
index 3c8c0c5b8..515b34418 100644
--- a/pkg/kube/client.go
+++ b/pkg/kube/client.go
@@ -49,8 +49,6 @@ import (
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/printers"
-
-	"k8s.io/helm/pkg/logger"
 )
 
 // ErrNoObjectsVisited indicates that during a visit operation, no matching objects were found.
@@ -62,7 +60,7 @@ type Client struct {
 	// SchemaCacheDir is the path for loading cached schema.
 	SchemaCacheDir string
 
-	Logger logger.Logger
+	Log func(string, ...interface{})
 }
 
 // New create a new Client
@@ -70,7 +68,7 @@ func New(config clientcmd.ClientConfig) *Client {
 	return &Client{
 		Factory:        cmdutil.NewFactory(config),
 		SchemaCacheDir: clientcmd.RecommendedSchemaFile,
-		Logger:         logger.DefaultLogger,
+		Log:            func(_ string, _ ...interface{}) {},
 	}
 }
 
@@ -104,7 +102,7 @@ func (c *Client) Create(namespace string, reader io.Reader, timeout int64, shoul
 func (c *Client) newBuilder(namespace string, reader io.Reader) *resource.Result {
 	schema, err := c.Validator(true, c.SchemaCacheDir)
 	if err != nil {
-		c.Logger.Printf("warning: failed to load schema: %s", err)
+		c.Log("warning: failed to load schema: %s", err)
 	}
 	return c.NewBuilder().
 		ContinueOnError().
@@ -120,12 +118,12 @@ func (c *Client) newBuilder(namespace string, reader io.Reader) *resource.Result
 func (c *Client) BuildUnstructured(namespace string, reader io.Reader) (Result, error) {
 	schema, err := c.Validator(true, c.SchemaCacheDir)
 	if err != nil {
-		c.Logger.Printf("warning: failed to load schema: %s", err)
+		c.Log("warning: failed to load schema: %s", err)
 	}
 
 	mapper, typer, err := c.UnstructuredObject()
 	if err != nil {
-		c.Logger.Printf("failed to load mapper: %s", err)
+		c.Log("failed to load mapper: %s", err)
 		return nil, err
 	}
 	var result Result
@@ -160,9 +158,9 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) {
 	}
 	missing := []string{}
 	err = perform(infos, func(info *resource.Info) error {
-		c.Logger.Printf("Doing get for %s: %q", info.Mapping.GroupVersionKind.Kind, info.Name)
+		c.Log("Doing get for %s: %q", info.Mapping.GroupVersionKind.Kind, info.Name)
 		if err := info.Get(); err != nil {
-			c.Logger.Printf("WARNING: Failed Get for resource %q: %s", info.Name, err)
+			c.Log("WARNING: Failed Get for resource %q: %s", info.Name, err)
 			missing = append(missing, fmt.Sprintf("%v\t\t%s", info.Mapping.Resource, info.Name))
 			return nil
 		}
@@ -190,7 +188,7 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) {
 		}
 		for _, o := range ot {
 			if err := p.PrintObj(o, buf); err != nil {
-				c.Logger.Printf("failed to print object type %s, object: %q :\n %v", t, o, err)
+				c.Log("failed to print object type %s, object: %q :\n %v", t, o, err)
 				return "", err
 			}
 		}
@@ -243,7 +241,7 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
 			}
 
 			kind := info.Mapping.GroupVersionKind.Kind
-			c.Logger.Printf("Created a new %s called %q\n", kind, info.Name)
+			c.Log("Created a new %s called %q\n", kind, info.Name)
 			return nil
 		}
 
@@ -253,7 +251,7 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
 		}
 
 		if err := updateResource(c, info, originalInfo.Object, recreate); err != nil {
-			c.Logger.Printf("error updating the resource %q:\n\t %v", info.Name, err)
+			c.Log("error updating the resource %q:\n\t %v", info.Name, err)
 			updateErrors = append(updateErrors, err.Error())
 		}
 
@@ -268,9 +266,9 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader
 	}
 
 	for _, info := range original.Difference(target) {
-		c.Logger.Printf("Deleting %q in %s...", info.Name, info.Namespace)
+		c.Log("Deleting %q in %s...", info.Name, info.Namespace)
 		if err := deleteResource(c, info); err != nil {
-			c.Logger.Printf("Failed to delete %q, err: %s", info.Name, err)
+			c.Log("Failed to delete %q, err: %s", info.Name, err)
 		}
 	}
 	if shouldWait {
@@ -288,7 +286,7 @@ func (c *Client) Delete(namespace string, reader io.Reader) error {
 		return err
 	}
 	return perform(infos, func(info *resource.Info) error {
-		c.Logger.Printf("Starting delete for %q %s", info.Name, info.Mapping.GroupVersionKind.Kind)
+		c.Log("Starting delete for %q %s", info.Name, info.Mapping.GroupVersionKind.Kind)
 		err := deleteResource(c, info)
 		return c.skipIfNotFound(err)
 	})
@@ -296,7 +294,7 @@ func (c *Client) Delete(namespace string, reader io.Reader) error {
 
 func (c *Client) skipIfNotFound(err error) error {
 	if errors.IsNotFound(err) {
-		c.Logger.Printf("%v", err)
+		c.Log("%v", err)
 		return nil
 	}
 	return err
@@ -360,7 +358,7 @@ func deleteResource(c *Client, info *resource.Info) error {
 		}
 		return err
 	}
-	c.Logger.Printf("Using reaper for deleting %q", info.Name)
+	c.Log("Using reaper for deleting %q", info.Name)
 	return reaper.Stop(info.Namespace, info.Name, 0, nil)
 }
 
@@ -400,7 +398,7 @@ func updateResource(c *Client, target *resource.Info, currentObj runtime.Object,
 		return fmt.Errorf("failed to create patch: %s", err)
 	}
 	if patch == nil {
-		c.Logger.Printf("Looks like there are no changes for %s %q", target.Mapping.GroupVersionKind.Kind, target.Name)
+		c.Log("Looks like there are no changes for %s %q", target.Mapping.GroupVersionKind.Kind, target.Name)
 		// This needs to happen to make sure that tiller has the latest info from the API
 		// Otherwise there will be no labels and other functions that use labels will panic
 		if err := target.Get(); err != nil {
@@ -450,7 +448,7 @@ func updateResource(c *Client, target *resource.Info, currentObj runtime.Object,
 
 	// Restart pods
 	for _, pod := range pods.Items {
-		c.Logger.Printf("Restarting pod: %v/%v", pod.Namespace, pod.Name)
+		c.Log("Restarting pod: %v/%v", pod.Namespace, pod.Name)
 
 		// Delete each pod for get them restarted with changed spec.
 		if err := client.Core().Pods(pod.Namespace).Delete(pod.Name, metav1.NewPreconditionDeleteOptions(string(pod.UID))); err != nil {
@@ -486,7 +484,7 @@ func (c *Client) watchUntilReady(timeout time.Duration, info *resource.Info) err
 	}
 
 	kind := info.Mapping.GroupVersionKind.Kind
-	c.Logger.Printf("Watching for changes to %s %s with timeout of %v", kind, info.Name, timeout)
+	c.Log("Watching for changes to %s %s with timeout of %v", kind, info.Name, timeout)
 
 	// What we watch for depends on the Kind.
 	// - For a Job, we watch for completion.
@@ -501,17 +499,17 @@ func (c *Client) watchUntilReady(timeout time.Duration, info *resource.Info) err
 			// we get. We care mostly about jobs, where what we want to see is
 			// the status go into a good state. For other types, like ReplicaSet
 			// we don't really do anything to support these as hooks.
-			c.Logger.Printf("Add/Modify event for %s: %v", info.Name, e.Type)
+			c.Log("Add/Modify event for %s: %v", info.Name, e.Type)
 			if kind == "Job" {
 				return c.waitForJob(e, info.Name)
 			}
 			return true, nil
 		case watch.Deleted:
-			c.Logger.Printf("Deleted event for %s", info.Name)
+			c.Log("Deleted event for %s", info.Name)
 			return true, nil
 		case watch.Error:
 			// Handle error and return with an error.
-			c.Logger.Printf("Error event for %s", info.Name)
+			c.Log("Error event for %s", info.Name)
 			return true, fmt.Errorf("Failed to deploy %s", info.Name)
 		default:
 			return false, nil
@@ -548,7 +546,7 @@ func (c *Client) waitForJob(e watch.Event, name string) (bool, error) {
 		}
 	}
 
-	c.Logger.Printf("%s: Jobs active: %d, jobs failed: %d, jobs succeeded: %d", name, o.Status.Active, o.Status.Failed, o.Status.Succeeded)
+	c.Log("%s: Jobs active: %d, jobs failed: %d, jobs succeeded: %d", name, o.Status.Active, o.Status.Failed, o.Status.Succeeded)
 	return false, nil
 }
 
@@ -597,7 +595,7 @@ func (c *Client) watchPodUntilComplete(timeout time.Duration, info *resource.Inf
 		return err
 	}
 
-	c.Logger.Printf("Watching pod %s for completion with timeout of %v", info.Name, timeout)
+	c.Log("Watching pod %s for completion with timeout of %v", info.Name, timeout)
 	_, err = watch.Until(timeout, w, func(e watch.Event) (bool, error) {
 		return conditions.PodCompleted(e)
 	})
diff --git a/pkg/kube/client_test.go b/pkg/kube/client_test.go
index c66fe3f82..26d38f4b3 100644
--- a/pkg/kube/client_test.go
+++ b/pkg/kube/client_test.go
@@ -42,8 +42,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/printers"
 	watchjson "k8s.io/kubernetes/pkg/watch/json"
-
-	"k8s.io/helm/pkg/logger"
 )
 
 func objBody(codec runtime.Codec, obj runtime.Object) io.ReadCloser {
@@ -141,10 +139,9 @@ func encodeAndMarshalEvent(e *watch.Event) ([]byte, error) {
 }
 
 func newTestClient(f cmdutil.Factory) *Client {
-	return &Client{
-		Factory: f,
-		Logger:  logger.NewNopLogger(),
-	}
+	c := New(nil)
+	c.Factory = f
+	return c
 }
 
 func TestUpdate(t *testing.T) {
diff --git a/pkg/logger/doc.go b/pkg/logger/doc.go
deleted file mode 100644
index 6f5ccdc33..000000000
--- a/pkg/logger/doc.go
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors All rights reserved.
-
-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 logger provides an abstract interface for logging.
-package logger // import "k8s.io/helm/pkg/logger"
diff --git a/pkg/logger/logger.go b/pkg/logger/logger.go
deleted file mode 100644
index f373d0407..000000000
--- a/pkg/logger/logger.go
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors All rights reserved.
-
-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 logger // import "k8s.io/helm/pkg/logger"
-
-// Logger provides a generic way of handling logging.
-type Logger interface {
-	Printf(format string, args ...interface{})
-}
-
-// Func is an adaptor to allow the use of ordinary functions as loggers.
-type Func func(string, ...interface{})
-
-// Printf implements Logger.
-func (l Func) Printf(format string, args ...interface{}) {
-	l(format, args...)
-}
-
-// DefaultLogger is a globally set Logger used when initializing clients.
-var DefaultLogger Logger = NewNopLogger()
-
-// NewNopLogger returns a Logger that does nothing.
-func NewNopLogger() Func { return func(_ string, _ ...interface{}) {} }
diff --git a/pkg/storage/driver/cfgmaps.go b/pkg/storage/driver/cfgmaps.go
index 79ac71224..1c30951f3 100644
--- a/pkg/storage/driver/cfgmaps.go
+++ b/pkg/storage/driver/cfgmaps.go
@@ -34,7 +34,6 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
 
-	"k8s.io/helm/pkg/logger"
 	rspb "k8s.io/helm/pkg/proto/hapi/release"
 )
 
@@ -50,14 +49,17 @@ var magicGzip = []byte{0x1f, 0x8b, 0x08}
 // ConfigMaps is a wrapper around an implementation of a kubernetes
 // ConfigMapsInterface.
 type ConfigMaps struct {
-	impl   internalversion.ConfigMapInterface
-	Logger logger.Logger
+	impl internalversion.ConfigMapInterface
+	Log  func(string, ...interface{})
 }
 
 // NewConfigMaps initializes a new ConfigMaps wrapping an implmenetation of
 // the kubernetes ConfigMapsInterface.
 func NewConfigMaps(impl internalversion.ConfigMapInterface) *ConfigMaps {
-	return &ConfigMaps{impl: impl}
+	return &ConfigMaps{
+		impl: impl,
+		Log:  func(_ string, _ ...interface{}) {},
+	}
 }
 
 // Name returns the name of the driver.
@@ -75,13 +77,13 @@ func (cfgmaps *ConfigMaps) Get(key string) (*rspb.Release, error) {
 			return nil, ErrReleaseNotFound(key)
 		}
 
-		cfgmaps.Logger.Printf("get: failed to get %q: %s", key, err)
+		cfgmaps.Log("get: failed to get %q: %s", key, err)
 		return nil, err
 	}
 	// found the configmap, decode the base64 data string
 	r, err := decodeRelease(obj.Data["release"])
 	if err != nil {
-		cfgmaps.Logger.Printf("get: failed to decode data %q: %s", key, err)
+		cfgmaps.Log("get: failed to decode data %q: %s", key, err)
 		return nil, err
 	}
 	// return the release object
@@ -97,7 +99,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
 
 	list, err := cfgmaps.impl.List(opts)
 	if err != nil {
-		cfgmaps.Logger.Printf("list: failed to list: %s", err)
+		cfgmaps.Log("list: failed to list: %s", err)
 		return nil, err
 	}
 
@@ -108,7 +110,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
 	for _, item := range list.Items {
 		rls, err := decodeRelease(item.Data["release"])
 		if err != nil {
-			cfgmaps.Logger.Printf("list: failed to decode release: %v: %s", item, err)
+			cfgmaps.Log("list: failed to decode release: %v: %s", item, err)
 			continue
 		}
 		if filter(rls) {
@@ -133,7 +135,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
 
 	list, err := cfgmaps.impl.List(opts)
 	if err != nil {
-		cfgmaps.Logger.Printf("query: failed to query with labels: %s", err)
+		cfgmaps.Log("query: failed to query with labels: %s", err)
 		return nil, err
 	}
 
@@ -145,7 +147,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
 	for _, item := range list.Items {
 		rls, err := decodeRelease(item.Data["release"])
 		if err != nil {
-			cfgmaps.Logger.Printf("query: failed to decode release: %s", err)
+			cfgmaps.Log("query: failed to decode release: %s", err)
 			continue
 		}
 		results = append(results, rls)
@@ -165,7 +167,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
 	// create a new configmap to hold the release
 	obj, err := newConfigMapsObject(key, rls, lbs)
 	if err != nil {
-		cfgmaps.Logger.Printf("create: failed to encode release %q: %s", rls.Name, err)
+		cfgmaps.Log("create: failed to encode release %q: %s", rls.Name, err)
 		return err
 	}
 	// push the configmap object out into the kubiverse
@@ -174,7 +176,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
 			return ErrReleaseExists(rls.Name)
 		}
 
-		cfgmaps.Logger.Printf("create: failed to create: %s", err)
+		cfgmaps.Log("create: failed to create: %s", err)
 		return err
 	}
 	return nil
@@ -192,13 +194,13 @@ func (cfgmaps *ConfigMaps) Update(key string, rls *rspb.Release) error {
 	// create a new configmap object to hold the release
 	obj, err := newConfigMapsObject(key, rls, lbs)
 	if err != nil {
-		cfgmaps.Logger.Printf("update: failed to encode release %q: %s", rls.Name, err)
+		cfgmaps.Log("update: failed to encode release %q: %s", rls.Name, err)
 		return err
 	}
 	// push the configmap object out into the kubiverse
 	_, err = cfgmaps.impl.Update(obj)
 	if err != nil {
-		cfgmaps.Logger.Printf("update: failed to update: %s", err)
+		cfgmaps.Log("update: failed to update: %s", err)
 		return err
 	}
 	return nil
@@ -212,7 +214,7 @@ func (cfgmaps *ConfigMaps) Delete(key string) (rls *rspb.Release, err error) {
 			return nil, ErrReleaseExists(rls.Name)
 		}
 
-		cfgmaps.Logger.Printf("delete: failed to get release %q: %s", key, err)
+		cfgmaps.Log("delete: failed to get release %q: %s", key, err)
 		return nil, err
 	}
 	// delete the release
diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go
index fe4cf1428..48a41fd12 100644
--- a/pkg/storage/storage.go
+++ b/pkg/storage/storage.go
@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"sync"
 
-	"k8s.io/helm/pkg/logger"
 	rspb "k8s.io/helm/pkg/proto/hapi/release"
 	relutil "k8s.io/helm/pkg/releaseutil"
 	"k8s.io/helm/pkg/storage/driver"
@@ -35,14 +34,14 @@ type Storage struct {
 	// releaseLocksLock is a mutex for accessing releaseLocks
 	releaseLocksLock *sync.Mutex
 
-	Logger logger.Logger
+	Log func(string, ...interface{})
 }
 
 // Get retrieves the release from storage. An error is returned
 // if the storage driver failed to fetch the release, or the
 // release identified by the key, version pair does not exist.
 func (s *Storage) Get(name string, version int32) (*rspb.Release, error) {
-	s.Logger.Printf("Getting release %q", makeKey(name, version))
+	s.Log("Getting release %q", makeKey(name, version))
 	return s.Driver.Get(makeKey(name, version))
 }
 
@@ -50,7 +49,7 @@ func (s *Storage) Get(name string, version int32) (*rspb.Release, error) {
 // error is returned if the storage driver failed to store the
 // release, or a release with identical an key already exists.
 func (s *Storage) Create(rls *rspb.Release) error {
-	s.Logger.Printf("Creating release %q", makeKey(rls.Name, rls.Version))
+	s.Log("Creating release %q", makeKey(rls.Name, rls.Version))
 	return s.Driver.Create(makeKey(rls.Name, rls.Version), rls)
 }
 
@@ -58,7 +57,7 @@ func (s *Storage) Create(rls *rspb.Release) error {
 // storage backend fails to update the release or if the release
 // does not exist.
 func (s *Storage) Update(rls *rspb.Release) error {
-	s.Logger.Printf("Updating release %q", makeKey(rls.Name, rls.Version))
+	s.Log("Updating release %q", makeKey(rls.Name, rls.Version))
 	return s.Driver.Update(makeKey(rls.Name, rls.Version), rls)
 }
 
@@ -66,21 +65,21 @@ func (s *Storage) Update(rls *rspb.Release) error {
 // the storage backend fails to delete the release or if the release
 // does not exist.
 func (s *Storage) Delete(name string, version int32) (*rspb.Release, error) {
-	s.Logger.Printf("Deleting release %q", makeKey(name, version))
+	s.Log("Deleting release %q", makeKey(name, version))
 	return s.Driver.Delete(makeKey(name, version))
 }
 
 // ListReleases returns all releases from storage. An error is returned if the
 // storage backend fails to retrieve the releases.
 func (s *Storage) ListReleases() ([]*rspb.Release, error) {
-	s.Logger.Printf("Listing all releases in storage")
+	s.Log("Listing all releases in storage")
 	return s.Driver.List(func(_ *rspb.Release) bool { return true })
 }
 
 // ListDeleted returns all releases with Status == DELETED. An error is returned
 // if the storage backend fails to retrieve the releases.
 func (s *Storage) ListDeleted() ([]*rspb.Release, error) {
-	s.Logger.Printf("Listing deleted releases in storage")
+	s.Log("Listing deleted releases in storage")
 	return s.Driver.List(func(rls *rspb.Release) bool {
 		return relutil.StatusFilter(rspb.Status_DELETED).Check(rls)
 	})
@@ -89,7 +88,7 @@ func (s *Storage) ListDeleted() ([]*rspb.Release, error) {
 // ListDeployed returns all releases with Status == DEPLOYED. An error is returned
 // if the storage backend fails to retrieve the releases.
 func (s *Storage) ListDeployed() ([]*rspb.Release, error) {
-	s.Logger.Printf("Listing all deployed releases in storage")
+	s.Log("Listing all deployed releases in storage")
 	return s.Driver.List(func(rls *rspb.Release) bool {
 		return relutil.StatusFilter(rspb.Status_DEPLOYED).Check(rls)
 	})
@@ -99,7 +98,7 @@ func (s *Storage) ListDeployed() ([]*rspb.Release, error) {
 // (filter0 && filter1 && ... && filterN), i.e. a Release is included in the results
 // if and only if all filters return true.
 func (s *Storage) ListFilterAll(fns ...relutil.FilterFunc) ([]*rspb.Release, error) {
-	s.Logger.Printf("Listing all releases with filter")
+	s.Log("Listing all releases with filter")
 	return s.Driver.List(func(rls *rspb.Release) bool {
 		return relutil.All(fns...).Check(rls)
 	})
@@ -109,7 +108,7 @@ func (s *Storage) ListFilterAll(fns ...relutil.FilterFunc) ([]*rspb.Release, err
 // (filter0 || filter1 || ... || filterN), i.e. a Release is included in the results
 // if at least one of the filters returns true.
 func (s *Storage) ListFilterAny(fns ...relutil.FilterFunc) ([]*rspb.Release, error) {
-	s.Logger.Printf("Listing any releases with filter")
+	s.Log("Listing any releases with filter")
 	return s.Driver.List(func(rls *rspb.Release) bool {
 		return relutil.Any(fns...).Check(rls)
 	})
@@ -118,7 +117,7 @@ func (s *Storage) ListFilterAny(fns ...relutil.FilterFunc) ([]*rspb.Release, err
 // Deployed returns the deployed release with the provided release name, or
 // returns ErrReleaseNotFound if not found.
 func (s *Storage) Deployed(name string) (*rspb.Release, error) {
-	s.Logger.Printf("Getting deployed release from %q history", name)
+	s.Log("Getting deployed release from %q history", name)
 
 	ls, err := s.Driver.Query(map[string]string{
 		"NAME":   name,
@@ -138,14 +137,14 @@ func (s *Storage) Deployed(name string) (*rspb.Release, error) {
 // History returns the revision history for the release with the provided name, or
 // returns ErrReleaseNotFound if no such release name exists.
 func (s *Storage) History(name string) ([]*rspb.Release, error) {
-	s.Logger.Printf("Getting release history for %q", name)
+	s.Log("Getting release history for %q", name)
 
 	return s.Driver.Query(map[string]string{"NAME": name, "OWNER": "TILLER"})
 }
 
 // Last fetches the last revision of the named release.
 func (s *Storage) Last(name string) (*rspb.Release, error) {
-	s.Logger.Printf("Getting last revision of %q", name)
+	s.Log("Getting last revision of %q", name)
 	h, err := s.History(name)
 	if err != nil {
 		return nil, err
@@ -221,6 +220,6 @@ func Init(d driver.Driver) *Storage {
 		Driver:           d,
 		releaseLocks:     make(map[string]*sync.Mutex),
 		releaseLocksLock: &sync.Mutex{},
-		Logger:           logger.DefaultLogger,
+		Log:              func(_ string, _ ...interface{}) {},
 	}
 }
diff --git a/pkg/tiller/release_server.go b/pkg/tiller/release_server.go
index b8beb7e65..363f2e692 100644
--- a/pkg/tiller/release_server.go
+++ b/pkg/tiller/release_server.go
@@ -32,7 +32,6 @@ import (
 
 	"k8s.io/helm/pkg/chartutil"
 	"k8s.io/helm/pkg/hooks"
-	"k8s.io/helm/pkg/logger"
 	"k8s.io/helm/pkg/proto/hapi/chart"
 	"k8s.io/helm/pkg/proto/hapi/release"
 	"k8s.io/helm/pkg/proto/hapi/services"
@@ -84,7 +83,7 @@ type ReleaseServer struct {
 	ReleaseModule
 	env       *environment.Environment
 	clientset internalclientset.Interface
-	Logger    logger.Logger
+	Log       func(string, ...interface{})
 }
 
 // NewReleaseServer creates a new release server.
@@ -102,7 +101,7 @@ func NewReleaseServer(env *environment.Environment, clientset internalclientset.
 		env:           env,
 		clientset:     clientset,
 		ReleaseModule: releaseModule,
-		Logger:        logger.DefaultLogger,
+		Log:           func(_ string, _ ...interface{}) {},
 	}
 }
 
@@ -270,7 +269,7 @@ func (s *ReleaseServer) GetReleaseStatus(c ctx.Context, req *services.GetRelease
 		// Skip errors if this is already deleted or failed.
 		return statusResp, nil
 	} else if err != nil {
-		s.Logger.Printf("warning: Get for %s failed: %v", rel.Name, err)
+		s.Log("warning: Get for %s failed: %v", rel.Name, err)
 		return nil, err
 	}
 	rel.Info.Status.Resources = resp
@@ -323,7 +322,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
 	res := &services.UpdateReleaseResponse{Release: updatedRelease}
 
 	if req.DryRun {
-		s.Logger.Printf("Dry run for %s", updatedRelease.Name)
+		s.Log("Dry run for %s", updatedRelease.Name)
 		res.Release.Info.Description = "Dry run complete"
 		return res, nil
 	}
@@ -336,7 +335,7 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
 	}
 	if err := s.ReleaseModule.Update(originalRelease, updatedRelease, req, s.env); err != nil {
 		msg := fmt.Sprintf("Upgrade %q failed: %s", updatedRelease.Name, err)
-		s.Logger.Printf("warning: %s", msg)
+		s.Log("warning: %s", msg)
 		originalRelease.Info.Status.Code = release.Status_SUPERSEDED
 		updatedRelease.Info.Status.Code = release.Status_FAILED
 		updatedRelease.Info.Description = msg
@@ -372,19 +371,19 @@ func (s *ReleaseServer) performUpdate(originalRelease, updatedRelease *release.R
 func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current *release.Release) error {
 	if req.ResetValues {
 		// If ResetValues is set, we comletely ignore current.Config.
-		s.Logger.Printf("Reset values to the chart's original version.")
+		s.Log("Reset values to the chart's original version.")
 		return nil
 	}
 
 	// If the ReuseValues flag is set, we always copy the old values over the new config's values.
 	if req.ReuseValues {
-		s.Logger.Printf("Reusing the old release's values")
+		s.Log("Reusing the old release's values")
 
 		// We have to regenerate the old coalesced values:
 		oldVals, err := chartutil.CoalesceValues(current.Chart, current.Config)
 		if err != nil {
 			err := fmt.Errorf("failed to rebuild old values: %s", err)
-			s.Logger.Printf("%s", err)
+			s.Log("%s", err)
 			return err
 		}
 		nv, err := oldVals.YAML()
@@ -401,7 +400,7 @@ func (s *ReleaseServer) reuseValues(req *services.UpdateReleaseRequest, current
 		current.Config != nil &&
 		current.Config.Raw != "" &&
 		current.Config.Raw != "{}\n" {
-		s.Logger.Printf("Copying values from %s (v%d) to new release.", current.Name, current.Version)
+		s.Log("Copying values from %s (v%d) to new release.", current.Name, current.Version)
 		req.Values = current.Config
 	}
 	return nil
@@ -510,7 +509,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
 	res := &services.RollbackReleaseResponse{Release: targetRelease}
 
 	if req.DryRun {
-		s.Logger.Printf("Dry run for %s", targetRelease.Name)
+		s.Log("Dry run for %s", targetRelease.Name)
 		return res, nil
 	}
 
@@ -523,7 +522,7 @@ func (s *ReleaseServer) performRollback(currentRelease, targetRelease *release.R
 
 	if err := s.ReleaseModule.Rollback(currentRelease, targetRelease, req, s.env); err != nil {
 		msg := fmt.Sprintf("Rollback %q failed: %s", targetRelease.Name, err)
-		s.Logger.Printf("warning: %s", msg)
+		s.Log("warning: %s", msg)
 		currentRelease.Info.Status.Code = release.Status_SUPERSEDED
 		targetRelease.Info.Status.Code = release.Status_FAILED
 		targetRelease.Info.Description = msg
@@ -567,7 +566,7 @@ func (s *ReleaseServer) prepareRollback(req *services.RollbackReleaseRequest) (*
 		rbv = crls.Version - 1
 	}
 
-	s.Logger.Printf("rolling back %s (current: v%d, target: v%d)", req.Name, crls.Version, rbv)
+	s.Log("rolling back %s (current: v%d, target: v%d)", req.Name, crls.Version, rbv)
 
 	prls, err := s.env.Releases.Get(req.Name, rbv)
 	if err != nil {
@@ -619,7 +618,7 @@ func (s *ReleaseServer) uniqName(start string, reuse bool) (string, error) {
 
 		if st := rel.Info.Status.Code; reuse && (st == release.Status_DELETED || st == release.Status_FAILED) {
 			// Allowe re-use of names if the previous release is marked deleted.
-			s.Logger.Printf("reusing name %q", start)
+			s.Log("reusing name %q", start)
 			return start, nil
 		} else if reuse {
 			return "", errors.New("cannot re-use a name that is still in use")
@@ -638,9 +637,9 @@ func (s *ReleaseServer) uniqName(start string, reuse bool) (string, error) {
 		if _, err := s.env.Releases.Get(name, 1); strings.Contains(err.Error(), "not found") {
 			return name, nil
 		}
-		s.Logger.Printf("info: Name %q is taken. Searching again.", name)
+		s.Log("info: Name %q is taken. Searching again.", name)
 	}
-	s.Logger.Printf("warning: No available release names found after %d tries", maxTries)
+	s.Log("warning: No available release names found after %d tries", maxTries)
 	return "ERROR", errors.New("no available release name found")
 }
 
@@ -650,7 +649,7 @@ func (s *ReleaseServer) engine(ch *chart.Chart) environment.Engine {
 		if r, ok := s.env.EngineYard.Get(ch.Metadata.Engine); ok {
 			renderer = r
 		} else {
-			s.Logger.Printf("warning: %s requested non-existent template engine %s", ch.Metadata.Name, ch.Metadata.Engine)
+			s.Log("warning: %s requested non-existent template engine %s", ch.Metadata.Name, ch.Metadata.Engine)
 		}
 	}
 	return renderer
@@ -660,7 +659,7 @@ func (s *ReleaseServer) engine(ch *chart.Chart) environment.Engine {
 func (s *ReleaseServer) InstallRelease(c ctx.Context, req *services.InstallReleaseRequest) (*services.InstallReleaseResponse, error) {
 	rel, err := s.prepareRelease(req)
 	if err != nil {
-		s.Logger.Printf("Failed install prepare step: %s", err)
+		s.Log("Failed install prepare step: %s", err)
 		res := &services.InstallReleaseResponse{Release: rel}
 
 		// On dry run, append the manifest contents to a failed release. This is
@@ -673,7 +672,7 @@ func (s *ReleaseServer) InstallRelease(c ctx.Context, req *services.InstallRelea
 
 	res, err := s.performRelease(rel, req)
 	if err != nil {
-		s.Logger.Printf("Failed install perform step: %s", err)
+		s.Log("Failed install perform step: %s", err)
 	}
 	return res, err
 }
@@ -856,10 +855,10 @@ func (s *ReleaseServer) renderResources(ch *chart.Chart, values chartutil.Values
 func (s *ReleaseServer) recordRelease(r *release.Release, reuse bool) {
 	if reuse {
 		if err := s.env.Releases.Update(r); err != nil {
-			s.Logger.Printf("warning: Failed to update release %q: %s", r.Name, err)
+			s.Log("warning: Failed to update release %q: %s", r.Name, err)
 		}
 	} else if err := s.env.Releases.Create(r); err != nil {
-		s.Logger.Printf("warning: Failed to record release %q: %s", r.Name, err)
+		s.Log("warning: Failed to record release %q: %s", r.Name, err)
 	}
 }
 
@@ -868,7 +867,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 	res := &services.InstallReleaseResponse{Release: r}
 
 	if req.DryRun {
-		s.Logger.Printf("Dry run for %s", r.Name)
+		s.Log("Dry run for %s", r.Name)
 		res.Release.Info.Description = "Dry run complete"
 		return res, nil
 	}
@@ -903,7 +902,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 		}
 		if err := s.ReleaseModule.Update(old, r, updateReq, s.env); err != nil {
 			msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err)
-			s.Logger.Printf("warning: %s", msg)
+			s.Log("warning: %s", msg)
 			old.Info.Status.Code = release.Status_SUPERSEDED
 			r.Info.Status.Code = release.Status_FAILED
 			r.Info.Description = msg
@@ -917,7 +916,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 		// regular manifests
 		if err := s.ReleaseModule.Create(r, req, s.env); err != nil {
 			msg := fmt.Sprintf("Release %q failed: %s", r.Name, err)
-			s.Logger.Printf("warning: %s", msg)
+			s.Log("warning: %s", msg)
 			r.Info.Status.Code = release.Status_FAILED
 			r.Info.Description = msg
 			s.recordRelease(r, false)
@@ -929,7 +928,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install
 	if !req.DisableHooks {
 		if err := s.execHook(r.Hooks, r.Name, r.Namespace, hooks.PostInstall, req.Timeout); err != nil {
 			msg := fmt.Sprintf("Release %q failed post-install: %s", r.Name, err)
-			s.Logger.Printf("warning: %s", msg)
+			s.Log("warning: %s", msg)
 			r.Info.Status.Code = release.Status_FAILED
 			r.Info.Description = msg
 			s.recordRelease(r, false)
@@ -958,7 +957,7 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
 		return fmt.Errorf("unknown hook %q", hook)
 	}
 
-	s.Logger.Printf("Executing %s hooks for %s", hook, name)
+	s.Log("Executing %s hooks for %s", hook, name)
 	executingHooks := []*release.Hook{}
 	for _, h := range hs {
 		for _, e := range h.Events {
@@ -974,20 +973,20 @@ func (s *ReleaseServer) execHook(hs []*release.Hook, name, namespace, hook strin
 
 		b := bytes.NewBufferString(h.Manifest)
 		if err := kubeCli.Create(namespace, b, timeout, false); err != nil {
-			s.Logger.Printf("warning: Release %q %s %s failed: %s", name, hook, h.Path, err)
+			s.Log("warning: Release %q %s %s failed: %s", name, hook, h.Path, err)
 			return err
 		}
 		// No way to rewind a bytes.Buffer()?
 		b.Reset()
 		b.WriteString(h.Manifest)
 		if err := kubeCli.WatchUntilReady(namespace, b, timeout, false); err != nil {
-			s.Logger.Printf("warning: Release %q %s %s could not complete: %s", name, hook, h.Path, err)
+			s.Log("warning: Release %q %s %s could not complete: %s", name, hook, h.Path, err)
 			return err
 		}
 		h.LastRun = timeconv.Now()
 	}
 
-	s.Logger.Printf("Hooks complete for %s %s", hook, name)
+	s.Log("Hooks complete for %s %s", hook, name)
 	return nil
 }
 
@@ -1009,7 +1008,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 	defer s.env.Releases.UnlockRelease(req.Name)
 
 	if !ValidName.MatchString(req.Name) {
-		s.Logger.Printf("uninstall: Release not found: %s", req.Name)
+		s.Log("uninstall: Release not found: %s", req.Name)
 		return nil, errMissingRelease
 	}
 
@@ -1019,7 +1018,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 
 	rels, err := s.env.Releases.History(req.Name)
 	if err != nil {
-		s.Logger.Printf("uninstall: Release not loaded: %s", req.Name)
+		s.Log("uninstall: Release not loaded: %s", req.Name)
 		return nil, err
 	}
 	if len(rels) < 1 {
@@ -1034,7 +1033,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 	if rel.Info.Status.Code == release.Status_DELETED {
 		if req.Purge {
 			if err := s.purgeReleases(rels...); err != nil {
-				s.Logger.Printf("uninstall: Failed to purge the release: %s", err)
+				s.Log("uninstall: Failed to purge the release: %s", err)
 				return nil, err
 			}
 			return &services.UninstallReleaseResponse{Release: rel}, nil
@@ -1042,7 +1041,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 		return nil, fmt.Errorf("the release named %q is already deleted", req.Name)
 	}
 
-	s.Logger.Printf("uninstall: Deleting %s", req.Name)
+	s.Log("uninstall: Deleting %s", req.Name)
 	rel.Info.Status.Code = release.Status_DELETING
 	rel.Info.Deleted = timeconv.Now()
 	rel.Info.Description = "Deletion in progress (or silently failed)"
@@ -1057,7 +1056,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 	// From here on out, the release is currently considered to be in Status_DELETING
 	// state.
 	if err := s.env.Releases.Update(rel); err != nil {
-		s.Logger.Printf("uninstall: Failed to store updated release: %s", err)
+		s.Log("uninstall: Failed to store updated release: %s", err)
 	}
 
 	kept, errs := s.ReleaseModule.Delete(rel, req, s.env)
@@ -1065,7 +1064,7 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 
 	es := make([]string, 0, len(errs))
 	for _, e := range errs {
-		s.Logger.Printf("error: %v", e)
+		s.Log("error: %v", e)
 		es = append(es, e.Error())
 	}
 
@@ -1081,13 +1080,13 @@ func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallR
 	if req.Purge {
 		err := s.purgeReleases(rels...)
 		if err != nil {
-			s.Logger.Printf("uninstall: Failed to purge the release: %s", err)
+			s.Log("uninstall: Failed to purge the release: %s", err)
 		}
 		return res, err
 	}
 
 	if err := s.env.Releases.Update(rel); err != nil {
-		s.Logger.Printf("uninstall: Failed to store updated release: %s", err)
+		s.Log("uninstall: Failed to store updated release: %s", err)
 	}
 
 	if len(es) > 0 {
@@ -1124,12 +1123,12 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
 
 	tSuite, err := reltesting.NewTestSuite(rel)
 	if err != nil {
-		s.Logger.Printf("Error creating test suite for %s", rel.Name)
+		s.Log("Error creating test suite for %s", rel.Name)
 		return err
 	}
 
 	if err := tSuite.Run(testEnv); err != nil {
-		s.Logger.Printf("Error running test suite for %s", rel.Name)
+		s.Log("Error running test suite for %s", rel.Name)
 		return err
 	}
 
@@ -1144,7 +1143,7 @@ func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream
 	}
 
 	if err := s.env.Releases.Update(rel); err != nil {
-		log.Printf("test: Failed to store updated release: %s", err)
+		s.Log("test: Failed to store updated release: %s", err)
 	}
 
 	return nil
diff --git a/pkg/tiller/release_server_test.go b/pkg/tiller/release_server_test.go
index 3d7f82e9e..8a5934b79 100644
--- a/pkg/tiller/release_server_test.go
+++ b/pkg/tiller/release_server_test.go
@@ -32,7 +32,6 @@ import (
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
 
 	"k8s.io/helm/pkg/helm"
-	"k8s.io/helm/pkg/logger"
 	"k8s.io/helm/pkg/proto/hapi/chart"
 	"k8s.io/helm/pkg/proto/hapi/release"
 	"k8s.io/helm/pkg/proto/hapi/services"
@@ -106,7 +105,7 @@ func rsFixture() *ReleaseServer {
 		},
 		env:       MockEnvironment(),
 		clientset: clientset,
-		Logger:    logger.NewNopLogger(),
+		Log:       func(_ string, _ ...interface{}) {},
 	}
 }