Repository: Azure/aad-pod-identity
Pull request #449 (2019-12-03 19:30:00)

move all packages to use klog
<!-- Thank you for helping AAD Pod Identity with a pull request! -->

**Reason for Change**:
<!-- What does this PR improve or fix in AAD Pod Identity? Why is it needed? -->
- Make NMI use klog instead of logrus
- Make logger uniform across MIC and NMI

**Issue Fixed**:
<!-- If this PR fixes GitHub issue 1234, add "Fixes #1234" to the next line. -->

**Notes for Reviewers**:



Patch:
diff --git a/cmd/demo/main.go b/cmd/demo/main.go
index 15bc7c1d..bef034ca 100644
--- a/cmd/demo/main.go
+++ b/cmd/demo/main.go
@@ -9,10 +9,10 @@ import (
 	"time"
 
 	compute "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute"
+	"k8s.io/klog"
 
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure/auth"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 )
 
@@ -31,121 +31,115 @@ func main() {
 	podnamespace := os.Getenv("MY_POD_NAMESPACE")
 	podip := os.Getenv("MY_POD_IP")
 
-	log.Infof("starting demo pod %s/%s %s", podnamespace, podname, podip)
-
-	logger := log.WithFields(log.Fields{
-		"podnamespace": podnamespace,
-		"podname":      podname,
-		"podip":        podip,
-	})
+	klog.Infof("starting demo pod %s/%s %s", podnamespace, podname, podip)
 
 	msiEndpoint, err := adal.GetMSIVMEndpoint()
 	if err != nil {
-		logger.Fatalf("failed to get msiendpoint, %+v", err)
+		klog.Fatalf("failed to get msiendpoint, %+v", err)
 	}
 
 	for {
-		doARMOperations(logger, *subscriptionID, *resourceGroup)
+		doARMOperations(*subscriptionID, *resourceGroup)
 
-		t1 := testMSIEndpoint(logger, msiEndpoint, *resource)
+		t1 := testMSIEndpoint(msiEndpoint, *resource)
 		if t1 == nil {
-			logger.Errorf("testMSIEndpoint failed, %+v", err)
+			klog.Errorf("testMSIEndpoint failed, %+v", err)
 			continue
 		}
 
-		t2 := testMSIEndpointFromUserAssignedID(logger, msiEndpoint, *clientID, *resource)
+		t2 := testMSIEndpointFromUserAssignedID(msiEndpoint, *clientID, *resource)
 		if t2 == nil {
-			logger.Errorf("testMSIEndpointFromUserAssignedID failed, %+v", err)
+			klog.Errorf("testMSIEndpointFromUserAssignedID failed, %+v", err)
 			continue
 		}
 
 		if !strings.EqualFold(t1.AccessToken, t2.AccessToken) {
-			logger.Errorf("msi, emsi test failed %+v %+v", t1, t2)
+			klog.Errorf("msi, emsi test failed %+v %+v", t1, t2)
 		}
 
-		testInstanceMetadataRequests(logger)
+		testInstanceMetadataRequests()
 
 		time.Sleep(time.Duration(*retryWaitTime) * time.Second)
 	}
 }
 
-func doARMOperations(logger *log.Entry, subscriptionID, resourceGroup string) {
+func doARMOperations(subscriptionID, resourceGroup string) {
 	authorizer, err := auth.NewAuthorizerFromEnvironment()
 	if err != nil {
-		logger.Errorf("failed NewAuthorizerFromEnvironment  %+v", authorizer)
+		klog.Errorf("failed NewAuthorizerFromEnvironment  %+v", err)
 		return
 	}
 	vmClient := compute.NewVirtualMachinesClient(subscriptionID)
 	vmClient.Authorizer = authorizer
 	vmlist, err := vmClient.List(context.Background(), resourceGroup)
 	if err != nil {
-		logger.Errorf("failed list all vm %+v", err)
+		klog.Errorf("failed list all vm %+v", err)
 		return
 	}
 
-	logger.Infof("successful doARMOperations vm count %d", len(vmlist.Values()))
+	klog.Infof("successful doARMOperations vm count %d", len(vmlist.Values()))
 }
 
-func testMSIEndpoint(logger *log.Entry, msiEndpoint, resource string) *adal.Token {
+func testMSIEndpoint(msiEndpoint, resource string) *adal.Token {
 	spt, err := adal.NewServicePrincipalTokenFromMSI(msiEndpoint, resource)
 	if err != nil {
-		logger.Errorf("failed to acquire a token using the MSI VM extension, Error: %+v", err)
+		klog.Errorf("failed to acquire a token using the MSI VM extension, Error: %+v", err)
 		return nil
 	}
 	if err := spt.Refresh(); err != nil {
-		logger.Errorf("failed to refresh ServicePrincipalTokenFromMSI using the MSI VM extension, msiEndpoint(%s)", msiEndpoint)
+		klog.Errorf("failed to refresh ServicePrincipalTokenFromMSI using the MSI VM extension, msiEndpoint(%s)", msiEndpoint)
 		return nil
 	}
 	token := spt.Token()
 	if token.IsZero() {
-		logger.Errorf("zero token found, MSI VM extension, msiEndpoint(%s)", msiEndpoint)
+		klog.Errorf("zero token found, MSI VM extension, msiEndpoint(%s)", msiEndpoint)
 		return nil
 	}
-	logger.Infof("successfully acquired a token using the MSI, msiEndpoint(%s)", msiEndpoint)
+	klog.Infof("successfully acquired a token using the MSI, msiEndpoint(%s)", msiEndpoint)
 	return &token
 }
 
-func testMSIEndpointFromUserAssignedID(logger *log.Entry, msiEndpoint, userAssignedID, resource string) *adal.Token {
+func testMSIEndpointFromUserAssignedID(msiEndpoint, userAssignedID, resource string) *adal.Token {
 	spt, err := adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, resource, userAssignedID)
 	if err != nil {
-		logger.Errorf("failed NewServicePrincipalTokenFromMSIWithUserAssignedID, clientID: %s Error: %+v", userAssignedID, err)
+		klog.Errorf("failed NewServicePrincipalTokenFromMSIWithUserAssignedID, clientID: %s Error: %+v", userAssignedID, err)
 		return nil
 	}
 	if err := spt.Refresh(); err != nil {
-		logger.Errorf("failed to refresh ServicePrincipalToken userAssignedID MSI, msiEndpoint(%s)", msiEndpoint)
+		klog.Errorf("failed to refresh ServicePrincipalToken userAssignedID MSI, msiEndpoint(%s)", msiEndpoint)
 		return nil
 	}
 	token := spt.Token()
 	if token.IsZero() {
-		logger.Errorf("zero token found, userAssignedID MSI, msiEndpoint(%s) clientID(%s)", msiEndpoint, userAssignedID)
+		klog.Errorf("zero token found, userAssignedID MSI, msiEndpoint(%s) clientID(%s)", msiEndpoint, userAssignedID)
 		return nil
 	}
-	logger.Infof("successfully acquired a token, userAssignedID MSI, msiEndpoint(%s) clientID(%s)", msiEndpoint, userAssignedID)
+	klog.Infof("successfully acquired a token, userAssignedID MSI, msiEndpoint(%s) clientID(%s)", msiEndpoint, userAssignedID)
 	return &token
 }
 
 // simulates health probe of non MSI instance metadata requests
 // e.g. curl -H Metadata:true "http://169.254.169.254/metadata/instance?api-version=2017-08-01" --header "X-Forwarded-For: 192.168.0.2"
-func testInstanceMetadataRequests(logger *log.Entry) {
+func testInstanceMetadataRequests() {
 	client := &http.Client{
 		Timeout: time.Duration(2) * time.Second,
 	}
 	req, err := http.NewRequest("GET", "http://169.254.169.254/metadata/instance?api-version=2017-08-01", nil)
 	if err != nil {
-		logger.Error(err)
+		klog.Error(err)
 		return
 	}
 	req.Header.Add("Metadata", "true")
 	resp, err := client.Do(req)
 	if err != nil {
-		logger.Error(err)
+		klog.Error(err)
 		return
 	}
 	defer resp.Body.Close()
 	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		logger.Error(err)
+		klog.Error(err)
 		return
 	}
-	logger.Infof("successfully made GET on instance metadata, %s", body)
+	klog.Infof("successfully made GET on instance metadata, %s", body)
 }
diff --git a/cmd/mic/main.go b/cmd/mic/main.go
index 4db5dc42..a9898d4f 100644
--- a/cmd/mic/main.go
+++ b/cmd/mic/main.go
@@ -12,9 +12,9 @@ import (
 	"github.com/Azure/aad-pod-identity/pkg/mic"
 	"github.com/Azure/aad-pod-identity/pkg/probes"
 	"github.com/Azure/aad-pod-identity/version"
-	"github.com/golang/glog"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/klog"
 )
 
 var (
@@ -34,10 +34,10 @@ var (
 )
 
 func main() {
-	defer glog.Flush()
+	defer klog.Flush()
 	hostName, err := os.Hostname()
 	if err != nil {
-		glog.Fatalf("Get hostname failure. Error: %+v", err)
+		klog.Fatalf("Get hostname failure. Error: %+v", err)
 	}
 	flag.StringVar(&kubeconfig, "kubeconfig", "", "Path to the kube config")
 	flag.StringVar(&cloudconfig, "cloudconfig", "", "Path to cloud config e.g. Azure.json file")
@@ -76,29 +76,29 @@ func main() {
 	if versionInfo {
 		version.PrintVersionAndExit()
 	}
-	glog.Infof("Starting mic process. Version: %v. Build date: %v", version.MICVersion, version.BuildDate)
+	klog.Infof("Starting mic process. Version: %v. Build date: %v", version.MICVersion, version.BuildDate)
 	if cloudconfig == "" {
-		glog.Warningf("--cloudconfig not passed will use aadpodidentity-admin-secret")
+		klog.Warningf("--cloudconfig not passed will use aadpodidentity-admin-secret")
 	}
 	if kubeconfig == "" {
-		glog.Warningf("--kubeconfig not passed will use InClusterConfig")
+		klog.Warningf("--kubeconfig not passed will use InClusterConfig")
 	}
 	if enableProfile {
 		profilePort := "6060"
-		glog.Infof("Starting profiling on port %s", profilePort)
+		klog.Infof("Starting profiling on port %s", profilePort)
 		go func() {
-			glog.Error(http.ListenAndServe("localhost:"+profilePort, nil))
+			klog.Error(http.ListenAndServe("localhost:"+profilePort, nil))
 		}()
 	}
 
 	if enableScaleFeatures {
-		glog.Infof("Enabling features for scale clusters")
+		klog.Infof("Enabling features for scale clusters")
 	}
 
-	glog.Infof("kubeconfig (%s) cloudconfig (%s)", kubeconfig, cloudconfig)
+	klog.Infof("kubeconfig (%s) cloudconfig (%s)", kubeconfig, cloudconfig)
 	config, err := buildConfig(kubeconfig)
 	if err != nil {
-		glog.Fatalf("Could not read config properly. Check the k8s config file, %+v", err)
+		klog.Fatalf("Could not read config properly. Check the k8s config file, %+v", err)
 	}
 	config.UserAgent = version.GetUserAgent("MIC", version.MICVersion)
 
@@ -106,7 +106,7 @@ func main() {
 
 	config.QPS = float32(clientQPS)
 	config.Burst = int(clientQPS)
-	glog.Infof("Client QPS set to: %v. Burst to: %v", config.QPS, config.Burst)
+	klog.Infof("Client QPS set to: %v. Burst to: %v", config.QPS, config.Burst)
 
 	var immutableUserMSIsList []string
 	if immutableUserMSIs != "" {
@@ -115,22 +115,22 @@ func main() {
 
 	micClient, err := mic.NewMICClient(cloudconfig, config, forceNamespaced, syncRetryDuration, &leaderElectionCfg, enableScaleFeatures, createDeleteBatch, immutableUserMSIsList)
 	if err != nil {
-		glog.Fatalf("Could not get the MIC client: %+v", err)
+		klog.Fatalf("Could not get the MIC client: %+v", err)
 	}
 
 	// Health probe will always report success once its started.
 	// MIC instance will report the contents as "Active" only once its elected the leader
 	// and starts the sync loop.
-	probes.InitAndStart(httpProbePort, &micClient.SyncLoopStarted, &mic.Log{})
+	probes.InitAndStart(httpProbePort, &micClient.SyncLoopStarted)
 
 	// Register and expose metrics views
-	if err = metrics.RegisterAndExport(prometheusPort, &mic.Log{}); err != nil {
-		glog.Fatalf("Could not register and export metrics: %+v", err)
+	if err = metrics.RegisterAndExport(prometheusPort); err != nil {
+		klog.Fatalf("Could not register and export metrics: %+v", err)
 	}
 
 	// Starts the leader election loop
 	micClient.Run()
-	glog.Info("AAD Pod identity controller initialized!!")
+	klog.Info("AAD Pod identity controller initialized!!")
 	//Infinite loop :-)
 	select {}
 }
diff --git a/cmd/nmi/main.go b/cmd/nmi/main.go
index d407e726..be92bedf 100644
--- a/cmd/nmi/main.go
+++ b/cmd/nmi/main.go
@@ -12,8 +12,8 @@ import (
 	server "github.com/Azure/aad-pod-identity/pkg/nmi/server"
 	"github.com/Azure/aad-pod-identity/pkg/probes"
 	"github.com/Azure/aad-pod-identity/version"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
+	"k8s.io/klog"
 )
 
 const (
@@ -56,28 +56,22 @@ func main() {
 		version.PrintVersionAndExit()
 	}
 
-	log.SetLevel(log.InfoLevel)
-	if *debug {
-		log.SetLevel(log.DebugLevel)
-	}
-	log.Infof("Starting nmi process. Version: %v. Build date: %v. Log level: %s.", version.NMIVersion, version.BuildDate, log.GetLevel())
+	klog.Infof("Starting nmi process. Version: %v. Build date: %v.", version.NMIVersion, version.BuildDate)
 
 	if *enableProfile {
 		profilePort := "6060"
-		log.Infof("Starting profiling on port %s", profilePort)
+		klog.Infof("Starting profiling on port %s", profilePort)
 		go func() {
-			log.Error(http.ListenAndServe("localhost:"+profilePort, nil))
+			klog.Error(http.ListenAndServe("localhost:"+profilePort, nil))
 		}()
 	}
 	if *enableScaleFeatures {
-		log.Infof("Features for scale clusters enabled")
+		klog.Infof("Features for scale clusters enabled")
 	}
 
-	logger := &server.Log{}
-
-	client, err := k8s.NewKubeClient(logger, *nodename, *enableScaleFeatures)
+	client, err := k8s.NewKubeClient(*nodename, *enableScaleFeatures)
 	if err != nil {
-		log.Fatalf("%+v", err)
+		klog.Fatalf("%+v", err)
 	}
 	exit := make(<-chan struct{})
 	client.Start(exit)
@@ -96,14 +90,14 @@ func main() {
 
 	// Health probe will always report success once its started. The contents
 	// will report "Active" once the iptables rules are set
-	probes.InitAndStart(*httpProbePort, &s.Initialized, logger)
+	probes.InitAndStart(*httpProbePort, &s.Initialized)
 
 	// Register and expose metrics views
-	if err = metrics.RegisterAndExport(*prometheusPort, logger); err != nil {
-		log.Fatalf("Could not register and export metrics: %+v", err)
+	if err = metrics.RegisterAndExport(*prometheusPort); err != nil {
+		klog.Fatalf("Could not register and export metrics: %+v", err)
 	}
 
 	if err := s.Run(); err != nil {
-		log.Fatalf("%s", err)
+		klog.Fatalf("%s", err)
 	}
 }
diff --git a/go.mod b/go.mod
index 2c527d40..dcd1a018 100644
--- a/go.mod
+++ b/go.mod
@@ -13,7 +13,6 @@ require (
 	github.com/Azure/go-autorest/autorest/validation v0.1.0 // indirect
 	github.com/coreos/go-iptables v0.3.0
 	github.com/gogo/protobuf v1.2.1 // indirect
-	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b
 	github.com/golang/groupcache v0.0.0-20180513044358-24b0969c4cb7 // indirect
 	github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf // indirect
 	github.com/googleapis/gnostic v0.1.0 // indirect
@@ -26,7 +25,6 @@ require (
 	github.com/onsi/ginkgo v1.7.0
 	github.com/onsi/gomega v1.4.3
 	github.com/pkg/errors v0.8.0
-	github.com/sirupsen/logrus v1.2.0
 	github.com/spf13/pflag v1.0.1
 	go.opencensus.io v0.22.0
 	golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6
@@ -36,5 +34,6 @@ require (
 	k8s.io/api v0.0.0-20180501062503-590a9173e3b6
 	k8s.io/apimachinery v0.0.0-20180417142332-01bc873149a1
 	k8s.io/client-go v0.0.0-20180424211516-33f2870a2b83
+	k8s.io/klog v1.0.0
 	k8s.io/kube-openapi v0.0.0-20190306001800-15615b16d372 // indirect
 )
diff --git a/go.sum b/go.sum
index 67349eb2..7e631159 100644
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,5 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-contrib.go.opencensus.io/exporter/ocagent v0.4.12 h1:jGFvw3l57ViIVEPKKEUXPcLYIXJmQxLUh6ey1eJhwyc=
 contrib.go.opencensus.io/exporter/ocagent v0.4.12/go.mod h1:450APlNTSR6FrvC3CTRqYosuDstRB9un7SOx2k/9ckA=
 contrib.go.opencensus.io/exporter/ocagent v0.5.0 h1:TKXjQSRS0/cCDrP7KvkgU6SmILtF/yV2TOs/02K/WZQ=
 contrib.go.opencensus.io/exporter/ocagent v0.5.0/go.mod h1:ImxhfLRpxoYiSq891pBrLVhN+qmP8BTVvdH2YLs7Gl0=
@@ -42,7 +41,6 @@ github.com/census-instrumentation/opencensus-proto v0.2.0/go.mod h1:f6KPmirojxKA
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/coreos/go-iptables v0.3.0 h1:UTQkjHl9rPwwtXZhXbY3T932cV9aUnKlSsZ7YGfJVXM=
 github.com/coreos/go-iptables v0.3.0/go.mod h1:/mVI274lEDI2ns62jHCDnCyBF9Iwsmekav8Dbxlm1MU=
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -59,9 +57,9 @@ github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.0 h1:xU6/SpYbvkNYiptHJYEDRseDLvYE7wSqhYYNy0QSUzI=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
@@ -70,7 +68,6 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfU
 github.com/golang/groupcache v0.0.0-20180513044358-24b0969c4cb7 h1:u4bArs140e9+AfE52mFHOXVFnOSBJBRlzTHrOPLOIhE=
 github.com/golang/groupcache v0.0.0-20180513044358-24b0969c4cb7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -86,7 +83,6 @@ github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/grpc-ecosystem/grpc-gateway v1.8.5 h1:2+KSC78XiO6Qy0hIjfc1OD9H+hsaJdJlb8Kqsd41CTE=
 github.com/grpc-ecosystem/grpc-gateway v1.8.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
@@ -103,7 +99,6 @@ github.com/kelseyhightower/envconfig v1.3.0 h1:IvRS4f2VcIQy6j4ORGIf9145T/AsUB+oY
 github.com/kelseyhightower/envconfig v1.3.0/go.mod h1:cccZRl6mQpaq41TPp5QxidR+Sa3axMbJDNb//FQX6Gg=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
@@ -120,7 +115,6 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
 github.com/modern-go/reflect2 v0.0.0-20180228065516-1df9eeb2bb81 h1:ImOHKpmdLPXWX5KSYquUWXKaopEPuY7TPPUo18u9aOI=
 github.com/modern-go/reflect2 v0.0.0-20180228065516-1df9eeb2bb81/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
@@ -148,7 +142,6 @@ github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1 h1:/K3IL0Z1quvmJ
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
-github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/spf13/pflag v1.0.1 h1:aCvUg6QPl3ibpQUxyLkrEkCHtPqYJL4x9AuhqVqFis4=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
@@ -158,14 +151,11 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
-go.opencensus.io v0.20.2 h1:NAfh7zF0/3/HqtMvJNZ/RFrSlCE6ZTlHmKfhL/Dm1Jk=
 go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0 h1:C9hSCOW830chIVkdja34wa6Ky+IzWllkUinR+BtRZd4=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793 h1:u+LnwYTOOW7Ukr/fppxEb1Nwz0AtPflrblfvUudpo+I=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190418165655-df01cb2cc480 h1:O5YqonU5IWby+w98jVUG9h7zlCWCcH4RHyPVReBmhzk=
 golang.org/x/crypto v0.0.0-20190418165655-df01cb2cc480/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
@@ -176,7 +166,6 @@ golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTk
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -184,13 +173,11 @@ golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09 h1:KaQtG+aDELoNmXYas3TVkGNYRuq8JQ1aa7LJt8EXVyo=
 golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -198,17 +185,14 @@ golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6 h1:bjcUS9ztw9kFmmIxJInhon/0
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd h1:r7DufRZuZbWB7j439YfAzP8RPDa9unLkpwQKUYbIMPI=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -221,26 +205,21 @@ golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-google.golang.org/api v0.3.1 h1:oJra/lMfmtm13/rgY/8i3MzjFWYXvQIAKjQ3HqofMk8=
 google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
 google.golang.org/api v0.4.0 h1:KKgc1aqhV8wDPbDzlDtpvyjZFY3vjz85FP7p4wcQUyI=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19 h1:Lj2SnHtxkRGJDqnGaSjo+CCdIieEnwVazbOXILwQemk=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb h1:i1Ppqkc3WQXikh8bXiwHqAN5Rv3/qDCcRk0/Otx73BY=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.19.1 h1:TrBcJ1yqAl1G++wO39nD/qtgpsW9/1+QGrluyMGEYgM=
 google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1 h1:Hz2g2wirWK7H0qIIhGIqRGTuMwTE8HEKFnDZZ7lm9NU=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -262,5 +241,7 @@ k8s.io/apimachinery v0.0.0-20180417142332-01bc873149a1 h1:lWAq9sN2fwiqI3Rnr3nDAS
 k8s.io/apimachinery v0.0.0-20180417142332-01bc873149a1/go.mod h1:ccL7Eh7zubPUSh9A3USN90/OzHNSVN6zxzde07TDCL0=
 k8s.io/client-go v0.0.0-20180424211516-33f2870a2b83 h1:zFG4vdZo+7VePgo3YFfw+ZZURiwY0BGAzdt20E6X9M0=
 k8s.io/client-go v0.0.0-20180424211516-33f2870a2b83/go.mod h1:7vJpHMYJwNQCWgzmNV+VYUl1zCObLyodBc8nIyt8L5s=
+k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8=
+k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
 k8s.io/kube-openapi v0.0.0-20190306001800-15615b16d372 h1:zia7dTzfEtdiSUxi9cXUDsSQH2xE6igmGKyFn2on/9A=
 k8s.io/kube-openapi v0.0.0-20190306001800-15615b16d372/go.mod h1:BXM9ceUBTj2QnfH2MK1odQs778ajze1RxcmP6S8RVVc=
diff --git a/pkg/cloudprovider/cloudprovider.go b/pkg/cloudprovider/cloudprovider.go
index 2a379b8d..17afc24f 100644
--- a/pkg/cloudprovider/cloudprovider.go
+++ b/pkg/cloudprovider/cloudprovider.go
@@ -17,8 +17,8 @@ import (
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/golang/glog"
 	yaml "gopkg.in/yaml.v2"
+	"k8s.io/klog"
 )
 
 // Client is a cloud provider client
@@ -41,18 +41,18 @@ type ClientInt interface {
 func NewCloudProvider(configFile string) (c *Client, e error) {
 	azureConfig := config.AzureConfig{}
 	if configFile != "" {
-		glog.V(6).Info("Populate AzureConfig from azure.json")
+		klog.V(6).Info("Populate AzureConfig from azure.json")
 		bytes, err := ioutil.ReadFile(configFile)
 		if err != nil {
-			glog.Errorf("Read file (%s) error: %+v", configFile, err)
+			klog.Errorf("Read file (%s) error: %+v", configFile, err)
 			return nil, err
 		}
 		if err = yaml.Unmarshal(bytes, &azureConfig); err != nil {
-			glog.Errorf("Unmarshall error: %v", err)
+			klog.Errorf("Unmarshall error: %v", err)
 			return nil, err
 		}
 	} else {
-		glog.V(6).Info("Populate AzureConfig from secret/environment variables")
+		klog.V(6).Info("Populate AzureConfig from secret/environment variables")
 		azureConfig.Cloud = os.Getenv("CLOUD")
 		azureConfig.TenantID = os.Getenv("TENANT_ID")
 		azureConfig.ClientID = os.Getenv("CLIENT_ID")
@@ -66,7 +66,7 @@ func NewCloudProvider(configFile string) (c *Client, e error) {
 
 	azureEnv, err := azure.EnvironmentFromName(azureConfig.Cloud)
 	if err != nil {
-		glog.Errorf("Get cloud env error: %+v", err)
+		klog.Errorf("Get cloud env error: %+v", err)
 		return nil, err
 	}
 
@@ -77,7 +77,7 @@ func NewCloudProvider(configFile string) (c *Client, e error) {
 
 	oauthConfig, err := adal.NewOAuthConfig(azureEnv.ActiveDirectoryEndpoint, azureConfig.TenantID)
 	if err != nil {
-		glog.Errorf("Create OAuth config error: %+v", err)
+		klog.Errorf("Create OAuth config error: %+v", err)
 		return nil, err
 	}
 
@@ -86,22 +86,22 @@ func NewCloudProvider(configFile string) (c *Client, e error) {
 		// MSI endpoint is required for both types of MSI - system assigned and user assigned.
 		msiEndpoint, err := adal.GetMSIVMEndpoint()
 		if err != nil {
-			glog.Errorf("Failed to get MSI endpoint. Error: %+v", err)
+			klog.Errorf("Failed to get MSI endpoint. Error: %+v", err)
 			return nil, err
 		}
 		// UserAssignedIdentityID is empty, so we are going to use system assigned MSI
 		if azureConfig.UserAssignedIdentityID == "" {
-			glog.Infof("MIC using system assigned identity for authentication.")
+			klog.Infof("MIC using system assigned identity for authentication.")
 			spt, err = adal.NewServicePrincipalTokenFromMSI(msiEndpoint, azureEnv.ResourceManagerEndpoint)
 			if err != nil {
-				glog.Errorf("Get token from system assigned MSI error: %+v", err)
+				klog.Errorf("Get token from system assigned MSI error: %+v", err)
 				return nil, err
 			}
 		} else { // User assigned identity usage.
-			glog.Infof("MIC using user assigned identity: %s for authentication.", utils.RedactClientID(azureConfig.UserAssignedIdentityID))
+			klog.Infof("MIC using user assigned identity: %s for authentication.", utils.RedactClientID(azureConfig.UserAssignedIdentityID))
 			spt, err = adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, azureEnv.ResourceManagerEndpoint, azureConfig.UserAssignedIdentityID)
 			if err != nil {
-				glog.Errorf("Get token from user assigned MSI error: %+v", err)
+				klog.Errorf("Get token from user assigned MSI error: %+v", err)
 				return nil, err
 			}
 		}
@@ -113,7 +113,7 @@ func NewCloudProvider(configFile string) (c *Client, e error) {
 			azureEnv.ResourceManagerEndpoint,
 		)
 		if err != nil {
-			glog.Errorf("Get service principal token error: %+v", err)
+			klog.Errorf("Get service principal token error: %+v", err)
 			return nil, err
 		}
 	}
@@ -130,12 +130,12 @@ func NewCloudProvider(configFile string) (c *Client, e error) {
 
 	client.VMSSClient, err = NewVMSSClient(azureConfig, spt)
 	if err != nil {
-		glog.Errorf("Create VMSS Client error: %+v", err)
+		klog.Errorf("Create VMSS Client error: %+v", err)
 		return nil, err
 	}
 	client.VMClient, err = NewVirtualMachinesClient(azureConfig, spt)
 	if err != nil {
-		glog.Errorf("Create VM Client error: %+v", err)
+		klog.Errorf("Create VM Client error: %+v", err)
 		return nil, err
 	}
 
@@ -145,7 +145,7 @@ func NewCloudProvider(configFile string) (c *Client, e error) {
 func withInspection() autorest.PrepareDecorator {
 	return func(p autorest.Preparer) autorest.Preparer {
 		return autorest.PreparerFunc(func(r *http.Request) (*http.Request, error) {
-			glog.Infof("Inspecting Request: Method: %s \n URL: %s, URI: %s\n", r.Method, r.URL, r.RequestURI)
+			klog.Infof("Inspecting Request: Method: %s \n URL: %s, URI: %s\n", r.Method, r.URL, r.RequestURI)
 
 			return p.Prepare(r)
 		})
@@ -156,7 +156,7 @@ func withInspection() autorest.PrepareDecorator {
 func (c *Client) GetUserMSIs(name string, isvmss bool) ([]string, error) {
 	idH, _, err := c.getIdentityResource(name, isvmss)
 	if err != nil {
-		glog.Errorf("GetUserMSIs: get identity resource failed with error %v", err)
+		klog.Errorf("GetUserMSIs: get identity resource failed with error %v", err)
 		return nil, err
 	}
 	info := idH.IdentityInfo()
@@ -191,17 +191,17 @@ func (c *Client) UpdateUserMSI(addUserAssignedMSIIDs, removeUserAssignedMSIIDs [
 	for _, userAssignedMSIID := range addUserAssignedMSIIDs {
 		addedToList := info.AppendUserIdentity(userAssignedMSIID)
 		if !addedToList {
-			glog.V(6).Infof("Identity %s already assigned to node %s. Skipping assignment.", userAssignedMSIID, name)
+			klog.V(6).Infof("Identity %s already assigned to node %s. Skipping assignment.", userAssignedMSIID, name)
 		}
 		requiresUpdate = requiresUpdate || addedToList
 	}
 	if requiresUpdate {
-		glog.Infof("Updating user assigned MSIs on %s", name)
+		klog.Infof("Updating user assigned MSIs on %s", name)
 		timeStarted := time.Now()
 		if err := updateFunc(); err != nil {
 			return err
 		}
-		glog.V(6).Infof("UpdateUserMSI of %s completed in %s", name, time.Since(timeStarted))
+		klog.V(6).Infof("UpdateUserMSI of %s completed in %s", name, time.Since(timeStarted))
 	}
 	return nil
 }
@@ -215,7 +215,7 @@ func (c *Client) RemoveUserMSI(userAssignedMSIID, name string, isvmss bool) erro
 
 	info := idH.IdentityInfo()
 	if info == nil {
-		glog.Errorf("Identity null for vm: %s ", name)
+		klog.Errorf("Identity null for vm: %s ", name)
 		return fmt.Errorf("identity null for vm: %s ", name)
 	}
 
@@ -224,7 +224,7 @@ func (c *Client) RemoveUserMSI(userAssignedMSIID, name string, isvmss bool) erro
 	}
 
 	if err := updateFunc(); err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return err
 	}
 
@@ -236,14 +236,14 @@ func (c *Client) AssignUserMSI(userAssignedMSIID, name string, isvmss bool) erro
 	// Get the vm using the VmClient
 	// Update the assigned identity into the VM using the CreateOrUpdate
 
-	glog.Infof("Find %s in resource group: %s", name, c.Config.ResourceGroupName)
+	klog.Infof("Find %s in resource group: %s", name, c.Config.ResourceGroupName)
 	timeStarted := time.Now()
 
 	idH, updateFunc, err := c.getIdentityResource(name, isvmss)
 	if err != nil {
 		return err
 	}
-	glog.V(6).Infof("Get of %s completed in %s", name, time.Since(timeStarted))
+	klog.V(6).Infof("Get of %s completed in %s", name, time.Since(timeStarted))
 
 	info := idH.IdentityInfo()
 	if info == nil {
@@ -255,9 +255,9 @@ func (c *Client) AssignUserMSI(userAssignedMSIID, name string, isvmss bool) erro
 		if err := updateFunc(); err != nil {
 			return err
 		}
-		glog.V(6).Infof("CreateOrUpdate of %s completed in %s", name, time.Since(timeStarted))
+		klog.V(6).Infof("CreateOrUpdate of %s completed in %s", name, time.Since(timeStarted))
 	} else {
-		glog.V(6).Infof("Identity %s already assigned to node %s. Skipping assignment.", userAssignedMSIID, name)
+		klog.V(6).Infof("Identity %s already assigned to node %s. Skipping assignment.", userAssignedMSIID, name)
 	}
 	return nil
 }
diff --git a/pkg/cloudprovider/vm.go b/pkg/cloudprovider/vm.go
index b299d752..53b19f60 100644
--- a/pkg/cloudprovider/vm.go
+++ b/pkg/cloudprovider/vm.go
@@ -12,7 +12,7 @@ import (
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/golang/glog"
+	"k8s.io/klog"
 )
 
 // VMClient client for VirtualMachines
@@ -33,7 +33,7 @@ func NewVirtualMachinesClient(config config.AzureConfig, spt *adal.ServicePrinci
 
 	azureEnv, err := azure.EnvironmentFromName(config.Cloud)
 	if err != nil {
-		glog.Errorf("Get cloud env error: %+v", err)
+		klog.Errorf("Get cloud env error: %+v", err)
 		return nil, err
 	}
 	client.BaseURI = azureEnv.ResourceManagerEndpoint
@@ -43,7 +43,7 @@ func NewVirtualMachinesClient(config config.AzureConfig, spt *adal.ServicePrinci
 
 	reporter, err := metrics.NewReporter()
 	if err != nil {
-		glog.Errorf("New reporter error: %+v", err)
+		klog.Errorf("New reporter error: %+v", err)
 		return nil, err
 	}
 
@@ -72,13 +72,13 @@ func (c *VMClient) CreateOrUpdate(rg string, nodeName string, vm compute.Virtual
 
 	future, err := c.client.CreateOrUpdate(ctx, rg, nodeName, vm)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return err
 	}
 
 	err = future.WaitForCompletionRef(ctx, c.client.Client)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return err
 	}
 	stats.UpdateCount(stats.TotalPutCalls, 1)
@@ -102,7 +102,7 @@ func (c *VMClient) Get(rgName string, nodeName string) (compute.VirtualMachine,
 
 	vm, err := c.client.Get(ctx, rgName, nodeName, "")
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return vm, err
 	}
 	stats.UpdateCount(stats.TotalGetCalls, 1)
diff --git a/pkg/cloudprovider/vmss.go b/pkg/cloudprovider/vmss.go
index 06c9adb7..57a01ff1 100644
--- a/pkg/cloudprovider/vmss.go
+++ b/pkg/cloudprovider/vmss.go
@@ -12,7 +12,7 @@ import (
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/golang/glog"
+	"k8s.io/klog"
 )
 
 // VMSSClient is used to interact with Azure virtual machine scale sets.
@@ -33,7 +33,7 @@ func NewVMSSClient(config config.AzureConfig, spt *adal.ServicePrincipalToken) (
 
 	azureEnv, err := azure.EnvironmentFromName(config.Cloud)
 	if err != nil {
-		glog.Errorf("Get cloud env error: %+v", err)
+		klog.Errorf("Get cloud env error: %+v", err)
 		return nil, err
 	}
 	client.BaseURI = azureEnv.ResourceManagerEndpoint
@@ -43,7 +43,7 @@ func NewVMSSClient(config config.AzureConfig, spt *adal.ServicePrincipalToken) (
 
 	reporter, err := metrics.NewReporter()
 	if err != nil {
-		glog.Errorf("New reporter error: %+v", err)
+		klog.Errorf("New reporter error: %+v", err)
 		return nil, err
 	}
 
@@ -72,13 +72,13 @@ func (c *VMSSClient) CreateOrUpdate(rg string, vmssName string, vm compute.Virtu
 
 	future, err := c.client.CreateOrUpdate(ctx, rg, vmssName, vm)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return err
 	}
 
 	err = future.WaitForCompletionRef(ctx, c.client.Client)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return err
 	}
 	stats.UpdateCount(stats.TotalPutCalls, 1)
@@ -100,7 +100,7 @@ func (c *VMSSClient) Get(rgName string, vmssName string) (ret compute.VirtualMac
 	}()
 	vm, err := c.client.Get(ctx, rgName, vmssName)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return vm, err
 	}
 	stats.UpdateCount(stats.TotalGetCalls, 1)
diff --git a/pkg/crd/crd.go b/pkg/crd/crd.go
index 312d892b..3dc6a79a 100644
--- a/pkg/crd/crd.go
+++ b/pkg/crd/crd.go
@@ -6,10 +6,7 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/golang/glog"
-
 	aadpodid "github.com/Azure/aad-pod-identity/pkg/apis/aadpodidentity/v1"
-	inlog "github.com/Azure/aad-pod-identity/pkg/logger"
 	"github.com/Azure/aad-pod-identity/pkg/metrics"
 	"github.com/Azure/aad-pod-identity/pkg/stats"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -21,6 +18,7 @@ import (
 	"k8s.io/client-go/informers/internalinterfaces"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/cache"
+	"k8s.io/klog"
 )
 
 // Client represents all the watchers
@@ -30,7 +28,6 @@ type Client struct {
 	IDInformer                   cache.SharedInformer
 	AssignedIDInformer           cache.SharedInformer
 	PodIdentityExceptionInformer cache.SharedInformer
-	log                          inlog.Logger
 	reporter                     *metrics.Reporter
 }
 
@@ -51,10 +48,10 @@ type ClientInt interface {
 }
 
 // NewCRDClientLite ...
-func NewCRDClientLite(config *rest.Config, log inlog.Logger, nodeName string, scale bool) (crdClient *Client, err error) {
+func NewCRDClientLite(config *rest.Config, nodeName string, scale bool) (crdClient *Client, err error) {
 	restClient, err := newRestClient(config)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
@@ -68,19 +65,19 @@ func NewCRDClientLite(config *rest.Config, log inlog.Logger, nodeName string, sc
 
 	assignedIDListInformer, err := newAssignedIDInformer(assignedIDListWatch)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 	podIdentityExceptionListWatch := newPodIdentityExceptionListWatch(restClient)
 	podIdentityExceptionInformer, err := newPodIdentityExceptionInformer(podIdentityExceptionListWatch)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
 	reporter, err := metrics.NewReporter()
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
@@ -88,43 +85,42 @@ func NewCRDClientLite(config *rest.Config, log inlog.Logger, nodeName string, sc
 		AssignedIDInformer:           assignedIDListInformer,
 		PodIdentityExceptionInformer: podIdentityExceptionInformer,
 		rest:                         restClient,
-		log:                          log,
 		reporter:                     reporter,
 	}, nil
 }
 
 // NewCRDClient returns a new crd client and error if any
-func NewCRDClient(config *rest.Config, eventCh chan aadpodid.EventType, log inlog.Logger) (crdClient *Client, err error) {
+func NewCRDClient(config *rest.Config, eventCh chan aadpodid.EventType) (crdClient *Client, err error) {
 	restClient, err := newRestClient(config)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
 	bindingListWatch := newBindingListWatch(restClient)
 	bindingInformer, err := newBindingInformer(restClient, eventCh, bindingListWatch)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
 	idListWatch := newIDListWatch(restClient)
 	idInformer, err := newIDInformer(restClient, eventCh, idListWatch)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
 	assignedIDListWatch := newAssignedIDListWatch(restClient)
 	assignedIDListInformer, err := newAssignedIDInformer(assignedIDListWatch)
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
 	reporter, err := metrics.NewReporter()
 	if err != nil {
-		log.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 
@@ -133,7 +129,6 @@ func NewCRDClient(config *rest.Config, eventCh chan aadpodid.EventType, log inlo
 		BindingInformer:    bindingInformer,
 		IDInformer:         idInformer,
 		AssignedIDInformer: assignedIDListInformer,
-		log:                log,
 		reporter:           reporter,
 	}, nil
 }
@@ -180,15 +175,15 @@ func newBindingInformer(r *rest.RESTClient, eventCh chan aadpodid.EventType, lw
 	azBindingInformer.AddEventHandler(
 		cache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
-				glog.V(6).Infof("Binding created")
+				klog.V(6).Infof("Binding created")
 				eventCh <- aadpodid.BindingCreated
 			},
 			DeleteFunc: func(obj interface{}) {
-				glog.V(6).Infof("Binding deleted")
+				klog.V(6).Infof("Binding deleted")
 				eventCh <- aadpodid.BindingDeleted
 			},
 			UpdateFunc: func(OldObj, newObj interface{}) {
-				glog.V(6).Infof("Binding updated")
+				klog.V(6).Infof("Binding updated")
 				eventCh <- aadpodid.BindingUpdated
 			},
 		},
@@ -211,15 +206,15 @@ func newIDInformer(r *rest.RESTClient, eventCh chan aadpodid.EventType, lw *cach
 	azIDInformer.AddEventHandler(
 		cache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
-				glog.V(6).Infof("Identity created")
+				klog.V(6).Infof("Identity created")
 				eventCh <- aadpodid.IdentityCreated
 			},
 			DeleteFunc: func(obj interface{}) {
-				glog.V(6).Infof("Identity deleted")
+				klog.V(6).Infof("Identity deleted")
 				eventCh <- aadpodid.IdentityDeleted
 			},
 			UpdateFunc: func(OldObj, newObj interface{}) {
-				glog.V(6).Infof("Identity updated")
+				klog.V(6).Infof("Identity updated")
 				eventCh <- aadpodid.IdentityUpdated
 			},
 		},
@@ -280,7 +275,7 @@ func (c *Client) StartLite(exit <-chan struct{}) {
 	go c.AssignedIDInformer.Run(exit)
 	go c.PodIdentityExceptionInformer.Run(exit)
 	c.SyncCacheLite(exit)
-	c.log.Info("CRD lite informers started ")
+	klog.Info("CRD lite informers started ")
 }
 
 // Start ...
@@ -289,7 +284,7 @@ func (c *Client) Start(exit <-chan struct{}) {
 	go c.IDInformer.Run(exit)
 	go c.AssignedIDInformer.Run(exit)
 	c.SyncCache(exit)
-	c.log.Info("CRD informers started")
+	klog.Info("CRD informers started")
 }
 
 func (c *Client) SyncCache(exit <-chan struct{}) {
@@ -307,7 +302,7 @@ func (c *Client) SyncCacheLite(exit <-chan struct{}) {
 func (c *Client) syncCache(exit <-chan struct{}, initial bool, cacheSyncs ...cache.InformerSynced) {
 	if !cache.WaitForCacheSync(exit, cacheSyncs...) {
 		if !initial {
-			c.log.Errorf("Cache could not be synchronized")
+			klog.Errorf("Cache could not be synchronized")
 			return
 		}
 		panic("Cache could not be synchronized")
@@ -316,7 +311,7 @@ func (c *Client) syncCache(exit <-chan struct{}, initial bool, cacheSyncs ...cac
 
 // RemoveAssignedIdentity removes the assigned identity
 func (c *Client) RemoveAssignedIdentity(assignedIdentity *aadpodid.AzureAssignedIdentity) (err error) {
-	glog.V(6).Infof("Deletion of assigned id named: %s", assignedIdentity.Name)
+	klog.V(6).Infof("Deletion of assigned id named: %s", assignedIdentity.Name)
 	begin := time.Now()
 
 	defer func() {
@@ -331,14 +326,14 @@ func (c *Client) RemoveAssignedIdentity(assignedIdentity *aadpodid.AzureAssigned
 	}()
 
 	err = c.rest.Delete().Namespace(assignedIdentity.Namespace).Resource("azureassignedidentities").Name(assignedIdentity.Name).Do().Error()
-	glog.V(5).Infof("Deletion %s took: %v", assignedIdentity.Name, time.Since(begin))
+	klog.V(5).Infof("Deletion %s took: %v", assignedIdentity.Name, time.Since(begin))
 	stats.Update(stats.AssignedIDDel, time.Since(begin))
 	return err
 }
 
 // CreateAssignedIdentity creates new assigned identity
 func (c *Client) CreateAssignedIdentity(assignedIdentity *aadpodid.AzureAssignedIdentity) (err error) {
-	glog.Infof("Got assigned id %s to assign", assignedIdentity.Name)
+	klog.Infof("Got assigned id %s to assign", assignedIdentity.Name)
 	begin := time.Now()
 
 	defer func() {
@@ -357,11 +352,11 @@ func (c *Client) CreateAssignedIdentity(assignedIdentity *aadpodid.AzureAssigned
 	// TODO: Ensure that the status reflects the corresponding
 	err = c.rest.Post().Namespace(assignedIdentity.Namespace).Resource("azureassignedidentities").Body(assignedIdentity).Do().Into(&res)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return err
 	}
 
-	glog.V(5).Infof("Time take to create %s: %v", assignedIdentity.Name, time.Since(begin))
+	klog.V(5).Infof("Time take to create %s: %v", assignedIdentity.Name, time.Since(begin))
 	stats.Update(stats.AssignedIDAdd, time.Since(begin))
 	return nil
 }
@@ -377,7 +372,7 @@ func (c *Client) ListBindings() (res *[]aadpodid.AzureIdentityBinding, err error
 		o, ok := binding.(*aadpodid.AzureIdentityBinding)
 		if !ok {
 			err := fmt.Errorf("could not cast %T to %s", binding, aadpodid.AzureIDBindingResource)
-			glog.Error(err)
+			klog.Error(err)
 			return nil, err
 		}
 		// Note: List items returned from cache have empty Kind and API version..
@@ -387,7 +382,7 @@ func (c *Client) ListBindings() (res *[]aadpodid.AzureIdentityBinding, err error
 			Version: aadpodid.CRDVersion,
 			Kind:    reflect.TypeOf(*o).String()})
 		resList = append(resList, *o)
-		glog.V(6).Infof("Appending binding: %s/%s to list.", o.Namespace, o.Name)
+		klog.V(6).Infof("Appending binding: %s/%s to list.", o.Namespace, o.Name)
 	}
 
 	stats.Update(stats.BindingList, time.Since(begin))
@@ -405,7 +400,7 @@ func (c *Client) ListAssignedIDs() (res *[]aadpodid.AzureAssignedIdentity, err e
 		o, ok := assignedID.(*aadpodid.AzureAssignedIdentity)
 		if !ok {
 			err := fmt.Errorf("could not cast %T to %s", assignedID, aadpodid.AzureAssignedIDResource)
-			c.log.Error(err)
+			klog.Error(err)
 			return nil, err
 		}
 		// Note: List items returned from cache have empty Kind and API version..
@@ -415,7 +410,7 @@ func (c *Client) ListAssignedIDs() (res *[]aadpodid.AzureAssignedIdentity, err e
 			Version: aadpodid.CRDVersion,
 			Kind:    reflect.TypeOf(*o).String()})
 		resList = append(resList, *o)
-		glog.V(6).Infof("Appending Assigned ID: %s/%s to list.", o.Namespace, o.Name)
+		klog.V(6).Infof("Appending Assigned ID: %s/%s to list.", o.Namespace, o.Name)
 	}
 
 	stats.Update(stats.AssignedIDList, time.Since(begin))
@@ -435,7 +430,7 @@ func (c *Client) ListAssignedIDsInMap() (map[string]aadpodid.AzureAssignedIdenti
 		o, ok := assignedID.(*aadpodid.AzureAssignedIdentity)
 		if !ok {
 			err := fmt.Errorf("could not cast %T to %s", assignedID, aadpodid.AzureAssignedIDResource)
-			c.log.Error(err)
+			klog.Error(err)
 			return nil, err
 		}
 		// Note: List items returned from cache have empty Kind and API version..
@@ -464,7 +459,7 @@ func (c *Client) ListIds() (res *[]aadpodid.AzureIdentity, err error) {
 		o, ok := id.(*aadpodid.AzureIdentity)
 		if !ok {
 			err := fmt.Errorf("could not cast %T to %s", id, aadpodid.AzureIDResource)
-			c.log.Error(err)
+			klog.Error(err)
 			return nil, err
 		}
 		// Note: List items returned from cache have empty Kind and API version..
@@ -474,7 +469,7 @@ func (c *Client) ListIds() (res *[]aadpodid.AzureIdentity, err error) {
 			Version: aadpodid.CRDVersion,
 			Kind:    reflect.TypeOf(*o).String()})
 		resList = append(resList, *o)
-		glog.V(6).Infof("Appending Identity: %s/%s to list.", o.Namespace, o.Name)
+		klog.V(6).Infof("Appending Identity: %s/%s to list.", o.Namespace, o.Name)
 	}
 
 	stats.Update(stats.IDList, time.Since(begin))
@@ -492,7 +487,7 @@ func (c *Client) ListPodIdentityExceptions(ns string) (res *[]aadpodid.AzurePodI
 		o, ok := binding.(*aadpodid.AzurePodIdentityException)
 		if !ok {
 			err := fmt.Errorf("could not cast %T to %s", binding, aadpodid.AzureIdentityExceptionResource)
-			c.log.Error(err)
+			klog.Error(err)
 			return nil, err
 		}
 		if o.Namespace == ns {
@@ -503,7 +498,7 @@ func (c *Client) ListPodIdentityExceptions(ns string) (res *[]aadpodid.AzurePodI
 				Version: aadpodid.CRDVersion,
 				Kind:    reflect.TypeOf(*o).String()})
 			resList = append(resList, *o)
-			glog.V(6).Infof("Appending exception: %s/%s to list.", o.Namespace, o.Name)
+			klog.V(6).Infof("Appending exception: %s/%s to list.", o.Namespace, o.Name)
 		}
 	}
 
@@ -536,7 +531,7 @@ type patchStatusOps struct {
 
 // UpdateAzureAssignedIdentityStatus updates the status field in AzureAssignedIdentity to indicate current status
 func (c *Client) UpdateAzureAssignedIdentityStatus(assignedIdentity *aadpodid.AzureAssignedIdentity, status string) (err error) {
-	glog.Infof("Updating assigned identity %s/%s status to %s", assignedIdentity.Namespace, assignedIdentity.Name, status)
+	klog.Infof("Updating assigned identity %s/%s status to %s", assignedIdentity.Namespace, assignedIdentity.Name, status)
 
 	defer func() {
 		if err != nil {
@@ -563,6 +558,6 @@ func (c *Client) UpdateAzureAssignedIdentityStatus(assignedIdentity *aadpodid.Az
 		Body(patchBytes).
 		Do().
 		Error()
-	glog.V(5).Infof("Patch of %s took: %v", assignedIdentity.Name, time.Since(begin))
+	klog.V(5).Infof("Patch of %s took: %v", assignedIdentity.Name, time.Since(begin))
 	return err
 }
diff --git a/pkg/k8s/client.go b/pkg/k8s/client.go
index 7347c35f..c679f845 100644
--- a/pkg/k8s/client.go
+++ b/pkg/k8s/client.go
@@ -12,14 +12,12 @@ import (
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/klog"
 
 	aadpodid "github.com/Azure/aad-pod-identity/pkg/apis/aadpodidentity/v1"
 	crd "github.com/Azure/aad-pod-identity/pkg/crd"
-	inlog "github.com/Azure/aad-pod-identity/pkg/logger"
 	"github.com/Azure/aad-pod-identity/pkg/metrics"
 	"github.com/Azure/aad-pod-identity/version"
-	"github.com/golang/glog"
-	log "github.com/sirupsen/logrus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	informersv1 "k8s.io/client-go/informers/core/v1"
 	"k8s.io/client-go/informers/internalinterfaces"
@@ -51,12 +49,11 @@ type KubeClient struct {
 	// Crd client used to access our CRD resources.
 	CrdClient   *crd.Client
 	PodInformer cache.SharedIndexInformer
-	log         inlog.Logger
 	reporter    *metrics.Reporter
 }
 
 // NewKubeClient new kubernetes api client
-func NewKubeClient(log inlog.Logger, nodeName string, scale bool) (Client, error) {
+func NewKubeClient(nodeName string, scale bool) (Client, error) {
 	config, err := buildConfig()
 	if err != nil {
 		return nil, err
@@ -66,7 +63,7 @@ func NewKubeClient(log inlog.Logger, nodeName string, scale bool) (Client, error
 	if err != nil {
 		return nil, err
 	}
-	crdclient, err := crd.NewCRDClientLite(config, log, nodeName, scale)
+	crdclient, err := crd.NewCRDClientLite(config, nodeName, scale)
 	if err != nil {
 		return nil, err
 	}
@@ -83,7 +80,6 @@ func NewKubeClient(log inlog.Logger, nodeName string, scale bool) (Client, error
 		CrdClient:   crdclient,
 		ClientSet:   clientset,
 		PodInformer: podInformer,
-		log:         log,
 		reporter:    reporter,
 	}
 
@@ -92,7 +88,7 @@ func NewKubeClient(log inlog.Logger, nodeName string, scale bool) (Client, error
 
 func (c *KubeClient) Sync(exit <-chan struct{}) {
 	if !cache.WaitForCacheSync(exit, c.PodInformer.HasSynced) {
-		c.log.Errorf("Pod cache could not be synchronized")
+		klog.Errorf("Pod cache could not be synchronized")
 	}
 	c.CrdClient.SyncCacheLite(exit)
 }
@@ -156,7 +152,7 @@ func (c *KubeClient) getPodList(podip string) ([]*v1.Pod, error) {
 		pod, ok := o.(*v1.Pod)
 		if !ok {
 			err := fmt.Errorf("could not cast %T to %s", pod, "v1.Pod")
-			glog.Error(err)
+			klog.Error(err)
 			return nil, err
 		}
 		if pod.Status.PodIP == podip && isPhaseValid(pod.Status.Phase) {
@@ -165,7 +161,7 @@ func (c *KubeClient) getPodList(podip string) ([]*v1.Pod, error) {
 	}
 	if len(podList) == 0 {
 		err := fmt.Errorf("pod list empty")
-		glog.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 	return podList, nil
@@ -188,7 +184,7 @@ func (c *KubeClient) getPodListRetry(podip string, retries int, sleeptime time.D
 			break
 		}
 		i++
-		log.Warningf("List pod error: %+v. Retrying, attempt number: %d", err, i)
+		klog.Warningf("List pod error: %+v. Retrying, attempt number: %d", err, i)
 		time.Sleep(sleeptime * time.Millisecond)
 	}
 	// We reach here only if there is an error and we have exhausted all retries.
diff --git a/pkg/logger/logger.go b/pkg/logger/logger.go
deleted file mode 100644
index 5aeb0156..00000000
--- a/pkg/logger/logger.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package logger
-
-// Logger - this interface is used to abstract the logging libraries used in MIC and NMI.
-type Logger interface {
-	Info(msg string)
-	Error(err error)
-	Infof(format string, args ...interface{})
-	Errorf(format string, args ...interface{})
-}
diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go
index 4e20fbd4..712c334a 100644
--- a/pkg/metrics/metrics.go
+++ b/pkg/metrics/metrics.go
@@ -5,10 +5,11 @@ import (
 	"sync"
 	"time"
 
-	log "github.com/Azure/aad-pod-identity/pkg/logger"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/stats/view"
 	"go.opencensus.io/tag"
+
+	"k8s.io/klog"
 )
 
 // This const block defines the metric names.
@@ -294,20 +295,20 @@ func (r *Reporter) ReportOperation(operationType string, measurement stats.Measu
 }
 
 // RegisterAndExport register the views for the measures and expose via prometheus exporter
-func RegisterAndExport(port string, log log.Logger) error {
+func RegisterAndExport(port string) error {
 	err := registerViews()
 	if err != nil {
-		log.Errorf("Failed to register views for metrics. error:%v", err)
+		klog.Errorf("Failed to register views for metrics. error:%v", err)
 		return err
 	}
-	log.Infof("Registered views for metric")
-	exporter, err := newPrometheusExporter(componentNamespace, port, log)
+	klog.Infof("Registered views for metric")
+	exporter, err := newPrometheusExporter(componentNamespace, port)
 	if err != nil {
-		log.Errorf("Prometheus exporter error: %+v", err)
+		klog.Errorf("Prometheus exporter error: %+v", err)
 		return err
 	}
 	view.RegisterExporter(exporter)
-	log.Infof("Registered and exported metrics on port %s", port)
+	klog.Infof("Registered and exported metrics on port %s", port)
 	return nil
 }
 
diff --git a/pkg/metrics/prometheus_exporter.go b/pkg/metrics/prometheus_exporter.go
index 45e57b54..f758f3fc 100644
--- a/pkg/metrics/prometheus_exporter.go
+++ b/pkg/metrics/prometheus_exporter.go
@@ -5,28 +5,29 @@ import (
 	"net/http"
 
 	"contrib.go.opencensus.io/exporter/prometheus"
-	log "github.com/Azure/aad-pod-identity/pkg/logger"
+
+	"k8s.io/klog"
 )
 
 // newPrometheusExporter creates prometheus exporter and run the same on given port
-func newPrometheusExporter(namespace string, portNumber string, log log.Logger) (*prometheus.Exporter, error) {
+func newPrometheusExporter(namespace string, portNumber string) (*prometheus.Exporter, error) {
 
 	prometheusExporter, err := prometheus.NewExporter(prometheus.Options{
 		Namespace: namespace,
 	})
 
 	if err != nil {
-		log.Errorf("Failed to create the Prometheus exporter. error: %+v", err)
+		klog.Errorf("Failed to create the Prometheus exporter. error: %+v", err)
 		return nil, err
 	}
-	log.Info("Starting Prometheus exporter")
+	klog.Info("Starting Prometheus exporter")
 	// Run the Prometheus exporter as a scrape endpoint.
 	go func() {
 		mux := http.NewServeMux()
 		mux.Handle("/metrics", prometheusExporter)
 		address := fmt.Sprintf(":%v", portNumber)
 		if err := http.ListenAndServe(address, mux); err != nil {
-			log.Errorf("Failed to run Prometheus scrape endpoint: %v", err)
+			klog.Errorf("Failed to run Prometheus scrape endpoint: %v", err)
 		}
 	}()
 	return prometheusExporter, nil
diff --git a/pkg/mic/log.go b/pkg/mic/log.go
deleted file mode 100644
index c58acf46..00000000
--- a/pkg/mic/log.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package mic
-
-import "github.com/golang/glog"
-
-// Log - this struct abstracts the logging libraries into single interface.
-type Log struct {
-}
-
-// Info - log the messages to be info
-func (l Log) Info(msg string) {
-	glog.Info(msg)
-}
-
-// Infof - log the messages to be info messages and formatted.
-func (l Log) Infof(format string, args ...interface{}) {
-	glog.Infof(format, &args)
-}
-
-// Errorf - log the messages to be error messages and formatted.
-func (l Log) Errorf(format string, args ...interface{}) {
-	glog.Errorf(format, &args)
-}
-
-// Error - log the messages to be error
-func (l Log) Error(err error) {
-	glog.Error(err)
-}
diff --git a/pkg/mic/mic.go b/pkg/mic/mic.go
index 13aa3126..9c29c3d5 100644
--- a/pkg/mic/mic.go
+++ b/pkg/mic/mic.go
@@ -16,7 +16,6 @@ import (
 	"github.com/Azure/aad-pod-identity/pkg/pod"
 	"github.com/Azure/aad-pod-identity/pkg/stats"
 	"github.com/Azure/aad-pod-identity/version"
-	"github.com/golang/glog"
 	"golang.org/x/sync/semaphore"
 	corev1 "k8s.io/api/core/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -28,6 +27,7 @@ import (
 	"k8s.io/client-go/tools/leaderelection"
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/client-go/tools/record"
+	"k8s.io/klog"
 )
 
 const (
@@ -89,13 +89,13 @@ type trackUserAssignedMSIIds struct {
 // NewMICClient returnes new mic client
 func NewMICClient(cloudconfig string, config *rest.Config, isNamespaced bool, syncRetryInterval time.Duration,
 	leaderElectionConfig *LeaderElectionConfig, enableScaleFeatures bool, createDeleteBatch int64, immutableUserMSIsList []string) (*Client, error) {
-	glog.Infof("Starting to create the pod identity client. Version: %v. Build date: %v", version.MICVersion, version.BuildDate)
+	klog.Infof("Starting to create the pod identity client. Version: %v. Build date: %v", version.MICVersion, version.BuildDate)
 
 	clientSet := kubernetes.NewForConfigOrDie(config)
 
 	k8sVersion, err := clientSet.ServerVersion()
 	if err == nil {
-		glog.Infof("Kubernetes server version: %s", k8sVersion.String())
+		klog.Infof("Kubernetes server version: %s", k8sVersion.String())
 	}
 
 	informer := informers.NewSharedInformerFactory(clientSet, 30*time.Second)
@@ -104,17 +104,17 @@ func NewMICClient(cloudconfig string, config *rest.Config, isNamespaced bool, sy
 	if err != nil {
 		return nil, err
 	}
-	glog.V(1).Infof("Cloud provider initialized")
+	klog.V(1).Infof("Cloud provider initialized")
 
 	eventCh := make(chan aadpodid.EventType, 100)
-	crdClient, err := crd.NewCRDClient(config, eventCh, Log{})
+	crdClient, err := crd.NewCRDClient(config, eventCh)
 	if err != nil {
 		return nil, err
 	}
-	glog.V(1).Infof("CRD client initialized")
+	klog.V(1).Infof("CRD client initialized")
 
 	podClient := pod.NewPodClient(informer, eventCh)
-	glog.V(1).Infof("Pod Client initialized")
+	klog.V(1).Infof("Pod Client initialized")
 
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartRecordingToSink(&typedcorev1.EventSinkImpl{Interface: clientSet.CoreV1().Events("")})
@@ -145,14 +145,14 @@ func NewMICClient(cloudconfig string, config *rest.Config, isNamespaced bool, sy
 	}
 	leaderElector, err := c.NewLeaderElector(clientSet, recorder, leaderElectionConfig)
 	if err != nil {
-		glog.Errorf("New leader elector failure. Error: %+v", err)
+		klog.Errorf("New leader elector failure. Error: %+v", err)
 		return nil, err
 	}
 	c.leaderElector = leaderElector
 
 	reporter, err := metrics.NewReporter()
 	if err != nil {
-		glog.Errorf("Not able to create New Reporter. Error: %+v", err)
+		klog.Errorf("Not able to create New Reporter. Error: %+v", err)
 		return nil, err
 	}
 	c.Reporter = reporter
@@ -161,7 +161,7 @@ func NewMICClient(cloudconfig string, config *rest.Config, isNamespaced bool, sy
 
 // Run - Initiates the leader election run call to find if its leader and run it
 func (c *Client) Run() {
-	glog.Infof("Initiating MIC Leader election")
+	klog.Info("Initiating MIC Leader election")
 	// counter to track number of mic election
 	c.Reporter.Report(metrics.MICNewLeaderElectionCountM.M(1))
 	c.leaderElector.Run()
@@ -178,7 +178,7 @@ func (c *Client) NewLeaderElector(clientSet *kubernetes.Clientset, recorder reco
 			Identity:      c.Instance,
 			EventRecorder: recorder})
 	if err != nil {
-		glog.Errorf("Resource lock creation for leader election failed with error : %v", err)
+		klog.Errorf("Resource lock creation for leader election failed with error : %v", err)
 		return nil, err
 	}
 	config := leaderelection.LeaderElectionConfig{
@@ -190,8 +190,8 @@ func (c *Client) NewLeaderElector(clientSet *kubernetes.Clientset, recorder reco
 				c.Start(exit)
 			},
 			OnStoppedLeading: func() {
-				glog.Errorf("Lost leader lease")
-				glog.Flush()
+				klog.Errorf("Lost leader lease")
+				klog.Flush()
 				os.Exit(1)
 			},
 		},
@@ -207,28 +207,28 @@ func (c *Client) NewLeaderElector(clientSet *kubernetes.Clientset, recorder reco
 
 // Start ...
 func (c *Client) Start(exit <-chan struct{}) {
-	glog.V(6).Infof("MIC client starting..")
+	klog.V(6).Infof("MIC client starting..")
 
 	var wg sync.WaitGroup
 
 	wg.Add(1)
 	go func() {
 		c.PodClient.Start(exit)
-		glog.V(6).Infof("Pod client started")
+		klog.V(6).Infof("Pod client started")
 		wg.Done()
 	}()
 
 	wg.Add(1)
 	go func() {
 		c.CRDClient.Start(exit)
-		glog.V(6).Infof("CRD client started")
+		klog.V(6).Infof("CRD client started")
 		wg.Done()
 	}()
 
 	wg.Add(1)
 	go func() {
 		c.NodeClient.Start(exit)
-		glog.V(6).Infof("Node client started")
+		klog.V(6).Infof("Node client started")
 		wg.Done()
 	}()
 
@@ -254,7 +254,7 @@ func (c *Client) Sync(exit <-chan struct{}) {
 	ticker := time.NewTicker(c.syncRetryInterval)
 	defer ticker.Stop()
 
-	glog.Info("Sync thread started.")
+	klog.Info("Sync thread started.")
 	c.SyncLoopStarted = true
 	var event aadpodid.EventType
 	totalWorkDoneCycles := 0
@@ -265,9 +265,9 @@ func (c *Client) Sync(exit <-chan struct{}) {
 		case <-exit:
 			return
 		case event = <-c.EventChannel:
-			glog.V(6).Infof("Received event: %v", event)
+			klog.V(6).Infof("Received event: %v", event)
 		case <-ticker.C:
-			glog.V(6).Infof("Running periodic sync loop")
+			klog.V(6).Infof("Running periodic sync loop")
 		}
 		totalSyncCycles++
 		stats.Init()
@@ -279,7 +279,7 @@ func (c *Client) Sync(exit <-chan struct{}) {
 		systemTime := time.Now()
 		listPods, err := c.PodClient.GetPods()
 		if err != nil {
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
 		listBindings, err := c.CRDClient.ListBindings()
@@ -292,7 +292,7 @@ func (c *Client) Sync(exit <-chan struct{}) {
 		}
 		idMap, err := c.convertIDListToMap(*listIDs)
 		if err != nil {
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
 
@@ -305,7 +305,7 @@ func (c *Client) Sync(exit <-chan struct{}) {
 		beginNewListTime := time.Now()
 		newAssignedIDs, nodeRefs, err := c.createDesiredAssignedIdentityList(listPods, listBindings, idMap)
 		if err != nil {
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
 		stats.Put(stats.CurrentState, time.Since(beginNewListTime))
@@ -314,15 +314,15 @@ func (c *Client) Sync(exit <-chan struct{}) {
 		// and the ones we have arrived at in the volatile list (newAssignedIDs).
 		addList, err := c.getAzureAssignedIDsToCreate(currentAssignedIDs, newAssignedIDs)
 		if err != nil {
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
 		deleteList, err := c.getAzureAssignedIDsToDelete(currentAssignedIDs, newAssignedIDs)
 		if err != nil {
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
-		glog.V(5).Infof("del: %v, add: %v", deleteList, addList)
+		klog.V(5).Infof("del: %v, add: %v", deleteList, addList)
 
 		// the node map is used to track assigned ids to create/delete, identities to assign/remove
 		// for each node or vmss
@@ -364,8 +364,8 @@ func (c *Client) Sync(exit <-chan struct{}) {
 			if listBindings != nil {
 				bindingsFound = len(*listBindings)
 			}
-			glog.Infof("Work done: %v. Found %d pods, %d ids, %d bindings", workDone, len(listPods), idsFound, bindingsFound)
-			glog.Infof("Total work cycles: %d, out of which work was done in: %d.", totalSyncCycles, totalWorkDoneCycles)
+			klog.Infof("Work done: %v. Found %d pods, %d ids, %d bindings", workDone, len(listPods), idsFound, bindingsFound)
+			klog.Infof("Total work cycles: %d, out of which work was done in: %d.", totalSyncCycles, totalWorkDoneCycles)
 			stats.Put(stats.Total, time.Since(begin))
 
 			c.Reporter.Report(
@@ -419,41 +419,41 @@ func (c *Client) createDesiredAssignedIdentityList(
 	for _, pod := range listPods {
 		if pod.Spec.NodeName == "" {
 			//Node is not yet allocated. In that case skip the pod
-			glog.V(2).Infof("Pod %s/%s has no assigned node yet. it will be ignored", pod.Namespace, pod.Name)
+			klog.V(2).Infof("Pod %s/%s has no assigned node yet. it will be ignored", pod.Namespace, pod.Name)
 			continue
 		}
 		crdPodLabelVal := pod.Labels[aadpodid.CRDLabelKey]
 		if crdPodLabelVal == "" {
 			//No binding mentioned in the label. Just continue to the next pod
-			glog.V(2).Infof("Pod %s/%s has correct %s label but with no value. it will be ignored", pod.Namespace, pod.Name, aadpodid.CRDLabelKey)
+			klog.V(2).Infof("Pod %s/%s has correct %s label but with no value. it will be ignored", pod.Namespace, pod.Name, aadpodid.CRDLabelKey)
 			continue
 		}
 		var matchedBindings []aadpodid.AzureIdentityBinding
 		for _, allBinding := range *listBindings {
 			if allBinding.Spec.Selector == crdPodLabelVal {
-				glog.V(5).Infof("Found binding match for pod %s/%s with binding %s/%s", pod.Namespace, pod.Name, allBinding.Namespace, allBinding.Name)
+				klog.V(5).Infof("Found binding match for pod %s/%s with binding %s/%s", pod.Namespace, pod.Name, allBinding.Namespace, allBinding.Name)
 				matchedBindings = append(matchedBindings, allBinding)
 				nodeRefs[pod.Spec.NodeName] = true
 			}
 		}
 
 		for _, binding := range matchedBindings {
-			glog.V(5).Infof("Looking up id map: %s/%s", binding.Namespace, binding.Spec.AzureIdentity)
+			klog.V(5).Infof("Looking up id map: %s/%s", binding.Namespace, binding.Spec.AzureIdentity)
 			if azureID, idPresent := idMap[getIDKey(binding.Namespace, binding.Spec.AzureIdentity)]; idPresent {
 				// working in Namespaced mode or this specific identity is namespaced
 				if c.IsNamespaced || aadpodid.IsNamespacedIdentity(&azureID) {
 					// They have to match all
 					if !(azureID.Namespace == binding.Namespace && binding.Namespace == pod.Namespace) {
-						glog.V(5).Infof("identity %s/%s was matched via binding %s/%s to %s/%s but namespaced identity is enforced, so it will be ignored",
+						klog.V(5).Infof("identity %s/%s was matched via binding %s/%s to %s/%s but namespaced identity is enforced, so it will be ignored",
 							azureID.Namespace, azureID.Name, binding.Namespace, binding.Name, pod.Namespace, pod.Name)
 						continue
 					}
 				}
-				glog.V(5).Infof("identity %s/%s assigned to %s/%s via %s/%s", azureID.Namespace, azureID.Name, pod.Namespace, pod.Name, binding.Namespace, binding.Name)
+				klog.V(5).Infof("identity %s/%s assigned to %s/%s via %s/%s", azureID.Namespace, azureID.Name, pod.Namespace, pod.Name, binding.Namespace, binding.Name)
 				assignedID, err := c.makeAssignedIDs(azureID, binding, pod.Name, pod.Namespace, pod.Spec.NodeName)
 
 				if err != nil {
-					glog.Errorf("failed to create assignment for pod %s/%s with identity %s/%s with error %v", pod.Namespace, pod.Name, azureID.Namespace, azureID.Name, err.Error())
+					klog.Errorf("failed to create assignment for pod %s/%s with identity %s/%s with error %v", pod.Namespace, pod.Name, azureID.Namespace, azureID.Name, err.Error())
 					continue
 				}
 				newAssignedIDs[assignedID.Name] = *assignedID
@@ -462,7 +462,7 @@ func (c *Client) createDesiredAssignedIdentityList(
 				// In such a case, we will skip it from matching binding.
 				// This will ensure that the new assigned ids created will not have the
 				// one associated with this azure identity.
-				glog.V(5).Infof("%s identity not found when using %s/%s binding", binding.Spec.AzureIdentity, binding.Namespace, binding.Name)
+				klog.V(5).Infof("%s identity not found when using %s/%s binding", binding.Spec.AzureIdentity, binding.Namespace, binding.Name)
 			}
 		}
 	}
@@ -477,14 +477,14 @@ func (c *Client) getListOfIdsToDelete(deleteList map[string]aadpodid.AzureAssign
 	nodeRefs map[string]bool) {
 	vmssGroups, err := getVMSSGroups(c.NodeClient, nodeRefs)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return
 	}
 	for _, delID := range deleteList {
-		glog.V(5).Infof("Deletion of id: %s", delID.Name)
+		klog.V(5).Infof("Deletion of id: %s", delID.Name)
 		inUse, err := c.checkIfInUse(delID, newAssignedIDs, vmssGroups)
 		if err != nil {
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
 
@@ -500,7 +500,7 @@ func (c *Client) getListOfIdsToDelete(deleteList map[string]aadpodid.AzureAssign
 				c.appendToRemoveListForNode(id.Spec.ResourceID, delID.Spec.NodeName, nodeMap)
 			}
 		}
-		glog.V(5).Infof("Binding removed: %+v", delID.Spec.AzureBindingRef)
+		klog.V(5).Infof("Binding removed: %+v", delID.Spec.AzureBindingRef)
 	}
 }
 
@@ -515,7 +515,7 @@ func (c *Client) getListOfIdsToAssign(addList map[string]aadpodid.AzureAssignedI
 				c.appendToAddListForNode(id.Spec.ResourceID, createID.Spec.NodeName, nodeMap)
 			}
 		}
-		glog.V(5).Infof("Binding applied: %+v", createID.Spec.AzureBindingRef)
+		klog.V(5).Infof("Binding applied: %+v", createID.Spec.AzureBindingRef)
 	}
 }
 
@@ -526,14 +526,14 @@ func (c *Client) matchAssignedID(x aadpodid.AzureAssignedIdentity, y aadpodid.Az
 	idX := x.Spec.AzureIdentityRef
 	idY := y.Spec.AzureIdentityRef
 
-	glog.V(7).Infof("assignedidX - %+v\n", x)
-	glog.V(7).Infof("assignedidY - %+v\n", y)
+	klog.V(7).Infof("assignedidX - %+v\n", x)
+	klog.V(7).Infof("assignedidY - %+v\n", y)
 
-	glog.V(7).Infof("bindingX - %+v\n", bindingX)
-	glog.V(7).Infof("bindingY - %+v\n", bindingY)
+	klog.V(7).Infof("bindingX - %+v\n", bindingX)
+	klog.V(7).Infof("bindingY - %+v\n", bindingY)
 
-	glog.V(7).Infof("idX - %+v\n", idX)
-	glog.V(7).Infof("idY - %+v\n", idY)
+	klog.V(7).Infof("idX - %+v\n", idX)
+	klog.V(7).Infof("idY - %+v\n", idY)
 
 	return bindingX.Name == bindingY.Name &&
 		bindingX.ResourceVersion == bindingY.ResourceVersion &&
@@ -563,13 +563,13 @@ func (c *Client) getAzureAssignedIDsToCreate(old, new map[string]aadpodid.AzureA
 			// if the old assigned id is in created state, then the identity assignment to the node
 			// is not done. Adding to the list will ensure we retry identity assignment to node for
 			// this assigned identity.
-			glog.V(5).Infof("ok: %v, Create added: %s", idMatch, assignedIDName)
+			klog.V(5).Infof("ok: %v, Create added: %s", idMatch, assignedIDName)
 			create[assignedIDName] = oldAssignedID
 		}
 		if !idMatch {
 			// We are done checking that this new id is not present in the old
 			// list. So we will add it to the create list.
-			glog.V(5).Infof("ok: %v, Create added: %s", idMatch, assignedIDName)
+			klog.V(5).Infof("ok: %v, Create added: %s", idMatch, assignedIDName)
 			create[assignedIDName] = newAssignedID
 		}
 	}
@@ -644,8 +644,8 @@ func (c *Client) makeAssignedIDs(azID aadpodid.AzureIdentity, azBinding aadpodid
 		assignedID.Namespace = "default"
 	}
 
-	glog.V(6).Infof("Binding - %+v Identity - %+v", azBinding, azID)
-	glog.V(5).Infof("Making assigned ID: %+v", assignedID)
+	klog.V(6).Infof("Binding - %+v Identity - %+v", azBinding, azID)
+	klog.V(5).Infof("Making assigned ID: %+v", assignedID)
 	return assignedID, nil
 }
 
@@ -784,7 +784,7 @@ func (c *Client) updateNodeAndDeps(newAssignedIDs map[string]aadpodid.AzureAssig
 func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedIdentity, nodeOrVMSSName string, nodeTrackList trackUserAssignedMSIIds, nodeRefs map[string]bool, wg *sync.WaitGroup) {
 	defer wg.Done()
 	beginAdding := time.Now()
-	glog.Infof("Processing node %s, add [%d], del [%d]", nodeOrVMSSName, len(nodeTrackList.assignedIDsToCreate), len(nodeTrackList.assignedIDsToDelete))
+	klog.Infof("Processing node %s, add [%d], del [%d]", nodeOrVMSSName, len(nodeTrackList.assignedIDsToCreate), len(nodeTrackList.assignedIDsToDelete))
 
 	ctx := context.TODO()
 	// We have to ensure that we don't overwhelm the API server with too many
@@ -795,7 +795,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	for _, createID := range nodeTrackList.assignedIDsToCreate {
 		if err := semCreate.Acquire(ctx, 1); err != nil {
-			glog.Errorf("Failed to acquire semaphore in the create loop: %v", err)
+			klog.Errorf("Failed to acquire semaphore in the create loop: %v", err)
 			return
 		}
 		go func(assignedID aadpodid.AzureAssignedIdentity) {
@@ -804,14 +804,14 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 				binding := assignedID.Spec.AzureBindingRef
 
 				// this is the state when the azure assigned identity is yet to be created
-				glog.V(5).Infof("Initiating assigned id creation for pod - %s, binding - %s", assignedID.Spec.Pod, binding.Name)
+				klog.V(5).Infof("Initiating assigned id creation for pod - %s, binding - %s", assignedID.Spec.Pod, binding.Name)
 
 				assignedID.Status.Status = aadpodid.AssignedIDCreated
 				err := c.createAssignedIdentity(&assignedID)
 				if err != nil {
 					c.EventRecorder.Event(binding, corev1.EventTypeWarning, "binding apply error",
 						fmt.Sprintf("Creating assigned identity for pod %s resulted in error %v", assignedID.Name, err))
-					glog.Error(err)
+					klog.Error(err)
 				}
 			}
 		}(createID)
@@ -819,7 +819,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	// Ensure that all creates are complete
 	if err := semCreate.Acquire(ctx, c.createDeleteBatch); err != nil {
-		glog.Errorf("Failed to acquire semaphore at the end of creates: %v", err)
+		klog.Errorf("Failed to acquire semaphore at the end of creates: %v", err)
 		return
 	}
 	// generate unique list so we don't make multiple calls to assign/remove same id
@@ -828,10 +828,10 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	err := c.CloudClient.UpdateUserMSI(addUserAssignedMSIIDs, removeUserAssignedMSIIDs, nodeOrVMSSName, nodeTrackList.isvmss)
 	if err != nil {
-		glog.Errorf("Updating msis on node %s, add [%d], del [%d] failed with error %v", nodeOrVMSSName, len(nodeTrackList.assignedIDsToCreate), len(nodeTrackList.assignedIDsToDelete), err)
+		klog.Errorf("Updating msis on node %s, add [%d], del [%d] failed with error %v", nodeOrVMSSName, len(nodeTrackList.assignedIDsToCreate), len(nodeTrackList.assignedIDsToDelete), err)
 		idList, getErr := c.getUserMSIListForNode(nodeOrVMSSName, nodeTrackList.isvmss)
 		if getErr != nil {
-			glog.Errorf("Getting list of msis from node %s resulted in error %v", nodeOrVMSSName, getErr)
+			klog.Errorf("Getting list of msis from node %s resulted in error %v", nodeOrVMSSName, getErr)
 			return
 		}
 
@@ -845,20 +845,20 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 			if isUserAssignedMSI && !idExistsOnNode {
 				message := fmt.Sprintf("Applying binding %s node %s for pod %s resulted in error %v", binding.Name, createID.Spec.NodeName, createID.Name, err.Error())
 				c.EventRecorder.Event(binding, corev1.EventTypeWarning, "binding apply error", message)
-				glog.Error(message)
+				klog.Error(message)
 				continue
 			}
 			// the identity was successfully assigned to the node
 			c.EventRecorder.Event(binding, corev1.EventTypeNormal, "binding applied",
 				fmt.Sprintf("Binding %s applied on node %s for pod %s", binding.Name, createID.Spec.NodeName, createID.Name))
 
-			glog.Infof("Updating msis on node %s failed, but identity %s has successfully been assigned to node", createID.Spec.NodeName, binding.Name)
+			klog.Infof("Updating msis on node %s failed, but identity %s has successfully been assigned to node", createID.Spec.NodeName, binding.Name)
 
 			// Identity is successfully assigned to node, so update the status of assigned identity to assigned
 			if updateErr := c.updateAssignedIdentityStatus(&createID, aadpodid.AssignedIDAssigned); updateErr != nil {
 				message := fmt.Sprintf("Updating assigned identity %s status to %s for pod %s failed with error %v", createID.Name, aadpodid.AssignedIDAssigned, createID.Spec.Pod, updateErr.Error())
 				c.EventRecorder.Event(&createID, corev1.EventTypeWarning, "status update error", message)
-				glog.Error(message)
+				klog.Error(message)
 			}
 		}
 
@@ -869,30 +869,30 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 			idExistsOnNode := c.checkIfMSIExistsOnNode(id, delID.Spec.NodeName, idList)
 			vmssGroups, getErr := getVMSSGroups(c.NodeClient, nodeRefs)
 			if getErr != nil {
-				glog.Error(getErr)
+				klog.Error(getErr)
 				continue
 			}
 			inUse, checkErr := c.checkIfInUse(delID, newAssignedIDs, vmssGroups)
 			if checkErr != nil {
-				glog.Error(checkErr)
+				klog.Error(checkErr)
 				continue
 			}
 			// the identity still exists on node, which means removing the identity from the node failed
 			if isUserAssignedMSI && !inUse && idExistsOnNode {
 				message := fmt.Sprintf("Binding %s removal from node %s for pod %s resulted in error %v", removedBinding.Name, delID.Spec.NodeName, delID.Spec.Pod, err.Error())
 				c.EventRecorder.Event(removedBinding, corev1.EventTypeWarning, "binding remove error", message)
-				glog.Error(message)
+				klog.Error(message)
 				continue
 			}
 
-			glog.Infof("Updating msis on node %s failed, but identity %s has successfully been removed from node", delID.Spec.NodeName, removedBinding.Name)
+			klog.Infof("Updating msis on node %s failed, but identity %s has successfully been removed from node", delID.Spec.NodeName, removedBinding.Name)
 
 			// remove assigned identity crd from cluster as the identity has successfully been removed from the node
 			err = c.removeAssignedIdentity(&delID)
 			if err != nil {
 				c.EventRecorder.Event(removedBinding, corev1.EventTypeWarning, "binding remove error",
 					fmt.Sprintf("Removing assigned identity binding %s node %s for pod %s resulted in error %v", removedBinding.Name, delID.Spec.NodeName, delID.Name, err.Error()))
-				glog.Error(err)
+				klog.Error(err)
 				continue
 			}
 			// the identity was successfully removed from node
@@ -907,7 +907,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	for _, createID := range nodeTrackList.assignedIDsToCreate {
 		if err := semUpdate.Acquire(ctx, 1); err != nil {
-			glog.Errorf("Failed to acquire semaphore in the update loop: %v", err)
+			klog.Errorf("Failed to acquire semaphore in the update loop: %v", err)
 			return
 		}
 		go func(assignedID aadpodid.AzureAssignedIdentity) {
@@ -918,7 +918,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 			if err != nil {
 				message := fmt.Sprintf("Updating assigned identity %s status to %s for pod %s failed with error %v", assignedID.Name, aadpodid.AssignedIDAssigned, assignedID.Spec.Pod, err.Error())
 				c.EventRecorder.Event(&assignedID, corev1.EventTypeWarning, "status update error", message)
-				glog.Error(message)
+				klog.Error(message)
 				return
 			}
 			c.EventRecorder.Event(binding, corev1.EventTypeNormal, "binding applied",
@@ -928,7 +928,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	// Ensure that all updates are complete
 	if err := semUpdate.Acquire(ctx, c.createDeleteBatch); err != nil {
-		glog.Errorf("Failed to acquire semaphore at the end of updates: %v", err)
+		klog.Errorf("Failed to acquire semaphore at the end of updates: %v", err)
 		return
 	}
 
@@ -936,7 +936,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	for _, delID := range nodeTrackList.assignedIDsToDelete {
 		if err := semDel.Acquire(ctx, 1); err != nil {
-			glog.Errorf("Failed to acquire semaphore in the delete loop: %v", err)
+			klog.Errorf("Failed to acquire semaphore in the delete loop: %v", err)
 			return
 		}
 		go func(assignedID aadpodid.AzureAssignedIdentity) {
@@ -948,7 +948,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 			if err != nil {
 				message := fmt.Sprintf("Updating assigned identity %s status to %s for pod %s failed with error %v", assignedID.Name, aadpodid.AssignedIDUnAssigned, assignedID.Spec.Pod, err.Error())
 				c.EventRecorder.Event(&assignedID, corev1.EventTypeWarning, "status update error", message)
-				glog.Error(message)
+				klog.Error(message)
 				return
 			}
 			// remove assigned identity crd from cluster as the identity has successfully been removed from the node
@@ -956,7 +956,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 			if err != nil {
 				c.EventRecorder.Event(removedBinding, corev1.EventTypeWarning, "binding remove error",
 					fmt.Sprintf("Removing assigned identity binding %s node %s for pod %s resulted in error %v", removedBinding.Name, assignedID.Spec.NodeName, assignedID.Name, err))
-				glog.Error(err)
+				klog.Error(err)
 				return
 			}
 			// the identity was successfully removed from node
@@ -967,7 +967,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 
 	// Ensure that all deletes are complete
 	if err := semDel.Acquire(ctx, c.createDeleteBatch); err != nil {
-		glog.Errorf("Failed to acquire semaphore at the end of deletes: %v", err)
+		klog.Errorf("Failed to acquire semaphore at the end of deletes: %v", err)
 		return
 	}
 
@@ -979,7 +979,7 @@ func (c *Client) updateUserMSI(newAssignedIDs map[string]aadpodid.AzureAssignedI
 // cleanUpAllAssignedIdentitiesOnNode deletes all assigned identities associated with a the node
 func (c *Client) cleanUpAllAssignedIdentitiesOnNode(node string, nodeTrackList trackUserAssignedMSIIds, wg *sync.WaitGroup) {
 	defer wg.Done()
-	glog.Infof("deleting all assigned identites for %s as node not found", node)
+	klog.Infof("deleting all assigned identites for %s as node not found", node)
 	for _, deleteID := range nodeTrackList.assignedIDsToDelete {
 		binding := deleteID.Spec.AzureBindingRef
 
@@ -987,7 +987,7 @@ func (c *Client) cleanUpAllAssignedIdentitiesOnNode(node string, nodeTrackList t
 		if err != nil {
 			c.EventRecorder.Event(binding, corev1.EventTypeWarning, "binding remove error",
 				fmt.Sprintf("Removing assigned identity binding %s node %s for pod %s resulted in error %v", binding.Name, deleteID.Spec.NodeName, deleteID.Name, err.Error()))
-			glog.Error(err)
+			klog.Error(err)
 			continue
 		}
 		c.EventRecorder.Event(binding, corev1.EventTypeNormal, "binding removed",
@@ -1004,11 +1004,11 @@ func (c *Client) consolidateVMSSNodes(nodeMap map[string]trackUserAssignedMSIIds
 	for nodeName, nodeTrackList := range nodeMap {
 		node, err := c.NodeClient.Get(nodeName)
 		if err != nil && !strings.Contains(err.Error(), "not found") {
-			glog.Errorf("Unable to get node %s. Error %v", nodeName, err)
+			klog.Errorf("Unable to get node %s. Error %v", nodeName, err)
 			continue
 		}
 		if err != nil && strings.Contains(err.Error(), "not found") {
-			glog.Warningf("Unable to get node %s while updating user msis. Error %v", nodeName, err)
+			klog.Warningf("Unable to get node %s while updating user msis. Error %v", nodeName, err)
 			wg.Add(1)
 			// node is no longer found in the cluster, all the assigned identities that were created in this sync loop
 			// and those that already exist for this node need to be deleted.
@@ -1018,7 +1018,7 @@ func (c *Client) consolidateVMSSNodes(nodeMap map[string]trackUserAssignedMSIIds
 		}
 		vmssName, isvmss, err := isVMSS(node)
 		if err != nil {
-			glog.Errorf("error checking if node %s is vmss. Error: %v", nodeName, err)
+			klog.Errorf("error checking if node %s is vmss. Error: %v", nodeName, err)
 			continue
 		}
 		if isvmss {
diff --git a/pkg/nmi/iptables/iptables.go b/pkg/nmi/iptables/iptables.go
index 337a72a3..d0712905 100644
--- a/pkg/nmi/iptables/iptables.go
+++ b/pkg/nmi/iptables/iptables.go
@@ -4,8 +4,9 @@ import (
 	"errors"
 	"strings"
 
+	"k8s.io/klog"
+
 	"github.com/coreos/go-iptables/iptables"
-	log "github.com/sirupsen/logrus"
 )
 
 var (
@@ -55,7 +56,7 @@ func LogCustomChain() error {
 	if err != nil {
 		return err
 	}
-	log.Debugf("Rules for table(%s) chain(%s) rules(%+v)", tablename, customchainname, strings.Join(rules, ", "))
+	klog.V(5).Infof("Rules for table(%s) chain(%s) rules(%+v)", tablename, customchainname, strings.Join(rules, ", "))
 
 	return nil
 }
diff --git a/pkg/nmi/server/log.go b/pkg/nmi/server/log.go
deleted file mode 100644
index 000683d3..00000000
--- a/pkg/nmi/server/log.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package server
-
-import (
-	log "github.com/sirupsen/logrus"
-)
-
-// Log - this struct abstracts the logging libraries into single interface.
-type Log struct {
-}
-
-// Info - log the messages to be info
-func (l Log) Info(msg string) {
-	log.Info(msg)
-}
-
-// Infof - log the messages to be info messages and formatted.
-func (l Log) Infof(format string, args ...interface{}) {
-	log.Infof(format, &args)
-}
-
-// Error - log the messages to be error
-func (l Log) Error(err error) {
-	log.Error(err)
-}
-
-// Errorf - log the messages to be error messages and formatted.
-func (l Log) Errorf(format string, args ...interface{}) {
-	log.Errorf(format, &args)
-}
diff --git a/pkg/nmi/server/server.go b/pkg/nmi/server/server.go
index 523f7af0..79574086 100644
--- a/pkg/nmi/server/server.go
+++ b/pkg/nmi/server/server.go
@@ -26,8 +26,7 @@ import (
 	"github.com/Azure/aad-pod-identity/pkg/pod"
 	utils "github.com/Azure/aad-pod-identity/pkg/utils"
 	"github.com/Azure/go-autorest/autorest/adal"
-
-	log "github.com/sirupsen/logrus"
+	"k8s.io/klog"
 )
 
 const (
@@ -65,7 +64,7 @@ type NMIResponse struct {
 func NewServer(isNamespaced bool, micNamespace string, blockInstanceMetadata bool) *Server {
 	reporter, err := metrics.NewReporter()
 	if err != nil {
-		log.Errorf("Error creating new reporter to emit metrics: %v", err)
+		klog.Errorf("Error creating new reporter to emit metrics: %v", err)
 	} else {
 		// keeping this reference to be used in ServeHTTP, as server is not accessible in ServeHTTP
 		appHandlerReporter = reporter
@@ -93,21 +92,21 @@ func (s *Server) Run() error {
 	}
 	mux.Handle("/", appHandler(s.defaultPathHandler))
 
-	log.Infof("Listening on port %s", s.NMIPort)
+	klog.Infof("Listening on port %s", s.NMIPort)
 	if err := http.ListenAndServe(":"+s.NMIPort, mux); err != nil {
-		log.Fatalf("Error creating http server: %+v", err)
+		klog.Fatalf("Error creating http server: %+v", err)
 	}
 	return nil
 }
 
 func (s *Server) updateIPTableRulesInternal() {
-	log.Debugf("node(%s) hostip(%s) metadataaddress(%s:%s) nmiport(%s)", s.NodeName, s.HostIP, s.MetadataIP, s.MetadataPort, s.NMIPort)
+	klog.V(5).Infof("node(%s) hostip(%s) metadataaddress(%s:%s) nmiport(%s)", s.NodeName, s.HostIP, s.MetadataIP, s.MetadataPort, s.NMIPort)
 
 	if err := iptables.AddCustomChain(s.MetadataIP, s.MetadataPort, s.HostIP, s.NMIPort); err != nil {
-		log.Fatalf("%s", err)
+		klog.Fatalf("%s", err)
 	}
 	if err := iptables.LogCustomChain(); err != nil {
-		log.Fatalf("%s", err)
+		klog.Fatalf("%s", err)
 	}
 }
 
@@ -140,7 +139,7 @@ loop:
 	}
 }
 
-type appHandler func(*log.Entry, http.ResponseWriter, *http.Request) string
+type appHandler func(http.ResponseWriter, *http.Request) string
 
 type responseWriter struct {
 	http.ResponseWriter
@@ -161,11 +160,8 @@ var appHandlerReporter *metrics.Reporter
 // ServeHTTP implements the net/http server handler interface
 // and recovers from panics.
 func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	logger := log.WithFields(log.Fields{
-		"req.method": r.Method,
-		"req.path":   r.URL.Path,
-		"req.remote": parseRemoteAddr(r.RemoteAddr),
-	})
+	tracker := fmt.Sprintf("req.method=%s reg.path=%s req.remote=%s", r.Method, r.URL.Path, parseRemoteAddr(r.RemoteAddr))
+
 	// Set the header in advance so that both success as well
 	// as error paths have it set as application/json content type.
 	w.Header().Set("Content-Type", "application/json")
@@ -183,15 +179,14 @@ func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			default:
 				err = errors.New("Unknown error")
 			}
-			logger.WithField("res.status", http.StatusInternalServerError).
-				Errorf("Panic processing request: %+v, file: %s, line: %d, stacktrace: '%s'", r, file, line, stack)
+			klog.Errorf("Panic processing request: %+v, file: %s, line: %d, stacktrace: '%s' %s res.status=%d", r, file, line, stack, tracker, http.StatusInternalServerError)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 		}
 	}()
 	rw := newResponseWriter(w)
-	ns := fn(logger, rw, r)
+	ns := fn(rw, r)
 	latency := time.Since(start)
-	logger.Infof("Status (%d) took %d ns", rw.statusCode, latency.Nanoseconds())
+	klog.Infof("Status (%d) took %d ns", rw.statusCode, latency.Nanoseconds())
 
 	_, resource := parseRequestClientIDAndResource(r)
 
@@ -205,33 +200,32 @@ func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *Server) hostHandler(logger *log.Entry, w http.ResponseWriter, r *http.Request) (ns string) {
+func (s *Server) hostHandler(w http.ResponseWriter, r *http.Request) (ns string) {
 	hostIP := parseRemoteAddr(r.RemoteAddr)
 	rqClientID, rqResource := parseRequestClientIDAndResource(r)
 
 	podns, podname := parseRequestHeader(r)
 	if podns == "" || podname == "" {
-		logger.Errorf("missing podname and podns from request")
+		klog.Error("missing podname and podns from request")
 		http.Error(w, "missing 'podname' and 'podns' from request header", http.StatusBadRequest)
 		return
 	}
 	// set the ns so it can be used for metrics
 	ns = podns
 	if hostIP != localhost {
-		msg := "request remote address is not from a host"
-		logger.Error(msg)
-		http.Error(w, msg, http.StatusInternalServerError)
+		klog.Errorf("request remote address is not from a host")
+		http.Error(w, "request remote address is not from a host", http.StatusInternalServerError)
 		return
 	}
 	if !validateResourceParamExists(rqResource) {
-		logger.Warning("parameter resource cannot be empty")
+		klog.Warning("parameter resource cannot be empty")
 		http.Error(w, "parameter resource cannot be empty", http.StatusBadRequest)
 		return
 	}
-	podIDs, identityInCreatedStateFound, err := s.listPodIDsWithRetry(r.Context(), s.KubeClient, logger, podns, podname, rqClientID)
+	podIDs, identityInCreatedStateFound, err := s.listPodIDsWithRetry(r.Context(), s.KubeClient, podns, podname, rqClientID)
 	if err != nil {
-		msg := fmt.Sprintf("no AzureAssignedIdentity found for pod:%s/%s in assigned state", podns, podname)
-		logger.Errorf("%s, %+v", msg, err)
+		msg := fmt.Sprintf("no AzureAssignedIdentity found for pod:%s/%s in desired state", podns, podname)
+		klog.Errorf("%s, %+v", msg, err)
 		http.Error(w, msg, getErrorResponseStatusCode(identityInCreatedStateFound))
 		return
 	}
@@ -246,7 +240,7 @@ func (s *Server) hostHandler(logger *log.Entry, w http.ResponseWriter, r *http.R
 				filterPodIdentities = append(filterPodIdentities, val)
 			} else {
 				// unmatched namespaced
-				logger.Errorf("pod:%s/%s has identity %s/%s but identity is namespaced will be ignored", podns, podname, val.Name, val.Namespace)
+				klog.Errorf("pod:%s/%s has identity %s/%s but identity is namespaced will be ignored", podns, podname, val.Name, val.Namespace)
 			}
 		} else {
 			// not in namespaced mode
@@ -254,9 +248,9 @@ func (s *Server) hostHandler(logger *log.Entry, w http.ResponseWriter, r *http.R
 		}
 	}
 	podIDs = filterPodIdentities
-	token, clientID, err := getTokenForMatchingID(s.KubeClient, logger, rqClientID, rqResource, podIDs)
+	token, clientID, err := getTokenForMatchingID(s.KubeClient, rqClientID, rqResource, podIDs)
 	if err != nil {
-		logger.Errorf("failed to get service principal token for pod:%s/%s, %+v", podns, podname, err)
+		klog.Errorf("failed to get service principal token for pod:%s/%s, err: %+v", podns, podname, err)
 		http.Error(w, err.Error(), http.StatusForbidden)
 		return
 	}
@@ -266,7 +260,7 @@ func (s *Server) hostHandler(logger *log.Entry, w http.ResponseWriter, r *http.R
 	}
 	response, err := json.Marshal(nmiResp)
 	if err != nil {
-		logger.Errorf("failed to marshal service principal token and clientid for pod:%s/%s, %+v", podns, podname, err)
+		klog.Errorf("failed to marshal service principal token and clientid for pod:%s/%s, err: %+v", podns, podname, err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -309,25 +303,25 @@ func (s *Server) isMIC(podNS, rsName string) bool {
 	return false
 }
 
-func (s *Server) getTokenForExceptedPod(logger *log.Entry, rqClientID, rqResource string) ([]byte, int, error) {
+func (s *Server) getTokenForExceptedPod(rqClientID, rqResource string) ([]byte, int, error) {
 	var token *adal.Token
 	var err error
 	// ClientID is empty, so we are going to use System assigned MSI
 	if rqClientID == "" {
-		logger.Infof("Fetching token for system assigned MSI")
+		klog.Infof("Fetching token for system assigned MSI")
 		token, err = auth.GetServicePrincipalTokenFromMSI(rqResource)
 	} else { // User assigned identity usage.
-		logger.Infof("Fetching token for user assigned MSI for id: %s", rqResource)
+		klog.Infof("Fetching token for user assigned MSI for resource: %s", rqResource)
 		token, err = auth.GetServicePrincipalTokenFromMSIWithUserAssignedID(rqClientID, rqResource)
 	}
 	if err != nil {
-		logger.Errorf("Failed to get service principal token. Error: %+v", err)
+		klog.Errorf("Failed to get service principal token, err: %+v", err)
 		// TODO: return the right status code based on the error we got from adal.
 		return nil, http.StatusForbidden, err
 	}
 	response, err := json.Marshal(newMSIResponse(*token))
 	if err != nil {
-		logger.Errorf("Failed to marshal service principal token. Error: %+v", err)
+		klog.Errorf("Failed to marshal service principal token, err: %+v", err)
 		return nil, http.StatusInternalServerError, err
 	}
 	return response, http.StatusOK, nil
@@ -338,24 +332,23 @@ func (s *Server) getTokenForExceptedPod(logger *log.Entry, rqClientID, rqResourc
 // AAD using adal
 // if the requests contains client id it validates it against the admin
 // configured id.
-func (s *Server) msiHandler(logger *log.Entry, w http.ResponseWriter, r *http.Request) (ns string) {
+func (s *Server) msiHandler(w http.ResponseWriter, r *http.Request) (ns string) {
 	podIP := parseRemoteAddr(r.RemoteAddr)
 	rqClientID, rqResource := parseRequestClientIDAndResource(r)
 
 	if podIP == "" {
-		msg := "request remote address is empty"
-		logger.Error(msg)
-		http.Error(w, msg, http.StatusInternalServerError)
+		klog.Error("request remote address is empty")
+		http.Error(w, "request remote address is empty", http.StatusInternalServerError)
 		return
 	}
 	if !validateResourceParamExists(rqResource) {
-		logger.Warning("parameter resource cannot be empty")
+		klog.Warning("parameter resource cannot be empty")
 		http.Error(w, "parameter resource cannot be empty", http.StatusBadRequest)
 		return
 	}
 	podns, podname, rsName, selectors, err := s.KubeClient.GetPodInfo(podIP)
 	if err != nil {
-		logger.Errorf("missing podname for podip:%s, %+v", podIP, err)
+		klog.Errorf("missing podname for podip:%s, %+v", podIP, err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -363,17 +356,17 @@ func (s *Server) msiHandler(logger *log.Entry, w http.ResponseWriter, r *http.Re
 	ns = podns
 	exceptionList, err := s.KubeClient.ListPodIdentityExceptions(podns)
 	if err != nil {
-		logger.Errorf("getting list of azurepodidentityexceptions failed with error: %+v", err)
+		klog.Errorf("getting list of azurepodidentityexceptions in %s namespace failed with error: %+v", podns, err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
 	// If its mic, then just directly get the token and pass back.
 	if pod.IsPodExcepted(selectors.MatchLabels, *exceptionList) || s.isMIC(podns, rsName) {
-		logger.Infof("Exception pod %s/%s token handling", podns, podname)
-		response, errorCode, err := s.getTokenForExceptedPod(logger, rqClientID, rqResource)
+		klog.Infof("Exception pod %s/%s token handling", podns, podname)
+		response, errorCode, err := s.getTokenForExceptedPod(rqClientID, rqResource)
 		if err != nil {
-			logger.Errorf("failed to get service principal token for pod:%s/%s.  Error code: %d. Error: %+v", podns, podname, errorCode, err)
+			klog.Errorf("failed to get service principal token for pod:%s/%s.  Error code: %d. Error: %+v", podns, podname, errorCode, err)
 			http.Error(w, err.Error(), errorCode)
 			return
 		}
@@ -381,23 +374,23 @@ func (s *Server) msiHandler(logger *log.Entry, w http.ResponseWriter, r *http.Re
 		return
 	}
 
-	podIDs, identityInCreatedStateFound, err := s.listPodIDsWithRetry(r.Context(), s.KubeClient, logger, podns, podname, rqClientID)
+	podIDs, identityInCreatedStateFound, err := s.listPodIDsWithRetry(r.Context(), s.KubeClient, podns, podname, rqClientID)
 	if err != nil {
 		msg := fmt.Sprintf("no AzureAssignedIdentity found for pod:%s/%s in assigned state", podns, podname)
-		logger.Errorf("%s, %+v", msg, err)
+		klog.Errorf("%s, %+v", msg, err)
 		http.Error(w, msg, getErrorResponseStatusCode(identityInCreatedStateFound))
 		return
 	}
 
-	token, _, err := getTokenForMatchingID(s.KubeClient, logger, rqClientID, rqResource, podIDs)
+	token, _, err := getTokenForMatchingID(s.KubeClient, rqClientID, rqResource, podIDs)
 	if err != nil {
-		logger.Errorf("failed to get service principal token for pod:%s/%s, %+v", podns, podname, err)
+		klog.Errorf("failed to get service principal token for pod:%s/%s, %+v", podns, podname, err)
 		http.Error(w, err.Error(), http.StatusForbidden)
 		return
 	}
 	response, err := json.Marshal(newMSIResponse(*token))
 	if err != nil {
-		logger.Errorf("failed to marshal service principal token for pod:%s/%s, %+v", podns, podname, err)
+		klog.Errorf("failed to marshal service principal token for pod:%s/%s, %+v", podns, podname, err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -405,24 +398,24 @@ func (s *Server) msiHandler(logger *log.Entry, w http.ResponseWriter, r *http.Re
 	return
 }
 
-func getTokenForMatchingID(kubeClient k8s.Client, logger *log.Entry, rqClientID string, rqResource string, podIDs []aadpodid.AzureIdentity) (token *adal.Token, clientID string, err error) {
+func getTokenForMatchingID(kubeClient k8s.Client, rqClientID, rqResource string, podIDs []aadpodid.AzureIdentity) (token *adal.Token, clientID string, err error) {
 	rqHasClientID := len(rqClientID) != 0
 	for _, v := range podIDs {
 		clientID := v.Spec.ClientID
 		if rqHasClientID && !strings.EqualFold(rqClientID, clientID) {
-			logger.Warningf("clientid mismatch, requested:%s available:%s", rqClientID, clientID)
+			klog.Warningf("clientid mismatch, requested:%s available:%s", rqClientID, clientID)
 			continue
 		}
 
 		idType := v.Spec.Type
 		switch idType {
 		case aadpodid.UserAssignedMSI:
-			logger.Infof("matched identityType:%v clientid:%s resource:%s", idType, utils.RedactClientID(clientID), rqResource)
+			klog.Infof("matched identityType:%v clientid:%s resource:%s", idType, utils.RedactClientID(clientID), rqResource)
 			token, err := auth.GetServicePrincipalTokenFromMSIWithUserAssignedID(clientID, rqResource)
 			return token, clientID, err
 		case aadpodid.ServicePrincipal:
 			tenantid := v.Spec.TenantID
-			logger.Infof("matched identityType:%v tenantid:%s clientid:%s resource:%s", idType, tenantid, utils.RedactClientID(clientID), rqResource)
+			klog.Infof("matched identityType:%v tenantid:%s clientid:%s resource:%s", idType, tenantid, utils.RedactClientID(clientID), rqResource)
 			secret, err := kubeClient.GetSecret(&v.Spec.ClientPassword)
 			if err != nil {
 				return nil, clientID, err
@@ -472,11 +465,11 @@ func parseRequestClientIDAndResource(r *http.Request) (clientID string, resource
 }
 
 // defaultPathHandler creates a new request and returns the response body and code
-func (s *Server) defaultPathHandler(logger *log.Entry, w http.ResponseWriter, r *http.Request) (ns string) {
+func (s *Server) defaultPathHandler(w http.ResponseWriter, r *http.Request) (ns string) {
 	client := &http.Client{}
 	req, err := http.NewRequest(r.Method, r.URL.String(), r.Body)
 	if err != nil || req == nil {
-		logger.Errorf("failed creating a new request, %s %+v", r.URL.String(), err)
+		klog.Errorf("failed creating a new request for %s, err: %+v", r.URL.String(), err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -489,7 +482,7 @@ func (s *Server) defaultPathHandler(logger *log.Entry, w http.ResponseWriter, r
 	}
 	resp, err := client.Do(req)
 	if err != nil {
-		logger.Errorf("failed executing request, %s %+v", req.URL.String(), err)
+		klog.Errorf("failed executing request for %s, err: %+v", req.URL.String(), err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -500,7 +493,7 @@ func (s *Server) defaultPathHandler(logger *log.Entry, w http.ResponseWriter, r
 	}()
 	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		logger.Errorf("failed io operation of reading response body, %+v", err)
+		klog.Errorf("failed io operation of reading response body for %s, %+v", req.URL.String(), err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
 	w.Write(body)
@@ -521,25 +514,25 @@ func copyHeader(dst, src http.Header) {
 }
 
 func handleTermination() {
-	log.Info("Received SIGTERM, shutting down")
+	klog.Info("Received SIGTERM, shutting down")
 
 	exitCode := 0
 	// clean up iptables
 	if err := iptables.DeleteCustomChain(); err != nil {
-		log.Errorf("Error cleaning up during shutdown: %v", err)
+		klog.Errorf("Error cleaning up during shutdown: %v", err)
 		exitCode = 1
 	}
 
 	// wait for pod to delete
-	log.Info("Handled termination, awaiting pod deletion")
+	klog.Info("Handled termination, awaiting pod deletion")
 	time.Sleep(10 * time.Second)
 
-	log.Infof("Exiting with %v", exitCode)
+	klog.Infof("Exiting with %v", exitCode)
 	os.Exit(exitCode)
 }
 
 // listPodIDsWithRetry returns a list of matched identities in Assigned state, boolean indicating if at least an identity was found in Created state and error if any
-func (s *Server) listPodIDsWithRetry(ctx context.Context, kubeClient k8s.Client, logger *log.Entry, podns, podname, rqClientID string) ([]aadpodid.AzureIdentity, bool, error) {
+func (s *Server) listPodIDsWithRetry(ctx context.Context, kubeClient k8s.Client, podns, podname, rqClientID string) ([]aadpodid.AzureIdentity, bool, error) {
 	attempt := 0
 	var err error
 	var idStateMap map[string][]aadpodid.AzureIdentity
@@ -555,7 +548,7 @@ func (s *Server) listPodIDsWithRetry(ctx context.Context, kubeClient k8s.Client,
 				// assigned identites created with old version of mic will not contain a state. So first we check to see if an assigned identity with
 				// no state exists that matches req client id.
 				if len(idStateMap[""]) != 0 {
-					logger.Warningf("found assignedIDs with no state for pod:%s/%s. AssignedIDs created with old version of mic.", podns, podname)
+					klog.Warningf("found assignedIDs with no state for pod:%s/%s. AssignedIDs created with old version of mic.", podns, podname)
 					return idStateMap[""], true, nil
 				}
 				if len(idStateMap[aadpodid.AssignedIDAssigned]) != 0 {
@@ -571,7 +564,7 @@ func (s *Server) listPodIDsWithRetry(ctx context.Context, kubeClient k8s.Client,
 				// check to ensure backward compatability with assignedIDs that have no state
 				for _, podID := range idStateMap[""] {
 					if strings.EqualFold(rqClientID, podID.Spec.ClientID) {
-						logger.Warningf("found assignedIDs with no state for pod:%s/%s. AssignedIDs created with old version of mic.", podns, podname)
+						klog.Warningf("found assignedIDs with no state for pod:%s/%s. AssignedIDs created with old version of mic.", podns, podname)
 						return idStateMap[""], true, nil
 					}
 				}
@@ -601,7 +594,7 @@ func (s *Server) listPodIDsWithRetry(ctx context.Context, kubeClient k8s.Client,
 			err = ctx.Err()
 			return nil, true, err
 		}
-		logger.Debugf("failed to get assigned ids for pod:%s/%s in ASSIGNED state, retrying attempt: %d", podns, podname, attempt)
+		klog.V(4).Infof("failed to get assigned ids for pod:%s/%s in ASSIGNED state, retrying attempt: %d", podns, podname, attempt)
 	}
 	return nil, true, fmt.Errorf("getting assigned identities for pod %s/%s in ASSIGNED state failed after %d attempts, retry duration [%d]s. Error: %v",
 		podns, podname, s.ListPodIDsRetryAttemptsForCreated+s.ListPodIDsRetryAttemptsForAssigned, s.ListPodIDsRetryIntervalInSeconds, err)
diff --git a/pkg/pod/pod.go b/pkg/pod/pod.go
index 44456a40..4ef84b01 100644
--- a/pkg/pod/pod.go
+++ b/pkg/pod/pod.go
@@ -6,28 +6,29 @@ import (
 
 	"github.com/Azure/aad-pod-identity/pkg/stats"
 
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/selection"
-
-	aadpodid "github.com/Azure/aad-pod-identity/pkg/apis/aadpodidentity/v1"
-	"github.com/golang/glog"
-
-	corev1 "k8s.io/api/core/v1"
-	v1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/informers"
 	informersv1 "k8s.io/client-go/informers/core/v1"
 	"k8s.io/client-go/tools/cache"
+	"k8s.io/klog"
+
+	aadpodid "github.com/Azure/aad-pod-identity/pkg/apis/aadpodidentity/v1"
 )
 
+// Client represents new pod client
 type Client struct {
 	PodWatcher informersv1.PodInformer
 }
 
+// ClientInt represents pod client interface
 type ClientInt interface {
-	GetPods() (pods []*corev1.Pod, err error)
+	GetPods() (pods []*v1.Pod, err error)
 	Start(exit <-chan struct{})
 }
 
+// NewPodClient returns new pod client
 func NewPodClient(i informers.SharedInformerFactory, eventCh chan aadpodid.EventType) (c ClientInt) {
 	podInformer := i.Core().V1().Pods()
 	addPodHandler(podInformer, eventCh)
@@ -41,12 +42,12 @@ func addPodHandler(i informersv1.PodInformer, eventCh chan aadpodid.EventType) {
 	i.Informer().AddEventHandler(
 		cache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
-				glog.V(6).Infof("Pod Created")
+				klog.V(6).Infof("Pod Created")
 				eventCh <- aadpodid.PodCreated
 
 			},
 			DeleteFunc: func(obj interface{}) {
-				glog.V(6).Infof("Pod Deleted")
+				klog.V(6).Infof("Pod Deleted")
 				eventCh <- aadpodid.PodDeleted
 
 			},
@@ -55,7 +56,7 @@ func addPodHandler(i informersv1.PodInformer, eventCh chan aadpodid.EventType) {
 				// Having this check will ensure that mic sync loop does not do extra work
 				// for every pod update.
 				if (OldObj.(*v1.Pod)).Spec.NodeName != (newObj.(*v1.Pod)).Spec.NodeName {
-					glog.V(6).Infof("Pod Updated")
+					klog.V(6).Infof("Pod Updated")
 					eventCh <- aadpodid.PodUpdated
 				}
 			},
@@ -65,27 +66,27 @@ func addPodHandler(i informersv1.PodInformer, eventCh chan aadpodid.EventType) {
 
 func (c *Client) syncCache(exit <-chan struct{}) {
 	cacheSyncStarted := time.Now()
-	glog.V(6).Infof("Wait for cache to sync")
+	klog.V(6).Infof("Wait for cache to sync")
 	if !cache.WaitForCacheSync(exit, c.PodWatcher.Informer().HasSynced) {
-		glog.Error("Wait for pod cache sync failed")
+		klog.Error("Wait for pod cache sync failed")
 		return
 	}
-	glog.Infof("Pod cache synchronized. Took %s", time.Since(cacheSyncStarted).String())
+	klog.Infof("Pod cache synchronized. Took %s", time.Since(cacheSyncStarted).String())
 }
 
 // Start ...
 func (c *Client) Start(exit <-chan struct{}) {
 	go c.PodWatcher.Informer().Run(exit)
 	c.syncCache(exit)
-	glog.Info("Pod watcher started !!")
+	klog.Info("Pod watcher started !!")
 }
 
 // GetPods returns list of all pods
-func (c *Client) GetPods() (pods []*corev1.Pod, err error) {
+func (c *Client) GetPods() (pods []*v1.Pod, err error) {
 	begin := time.Now()
 	crdReq, err := labels.NewRequirement(aadpodid.CRDLabelKey, selection.Exists, nil)
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		return nil, err
 	}
 	crdSelector := labels.NewSelector().Add(*crdReq)
diff --git a/pkg/probes/probes.go b/pkg/probes/probes.go
index b10f38f0..6c2b333c 100644
--- a/pkg/probes/probes.go
+++ b/pkg/probes/probes.go
@@ -3,7 +3,7 @@ package probes
 import (
 	"net/http"
 
-	log "github.com/Azure/aad-pod-identity/pkg/logger"
+	"k8s.io/klog"
 )
 
 // InitHealthProbe - sets up a health probe which responds with success (200 - OK) once its initialized.
@@ -21,26 +21,26 @@ func InitHealthProbe(condition *bool) {
 	})
 }
 
-func startAsync(port string, log log.Logger) {
+func startAsync(port string) {
 	err := http.ListenAndServe(":"+port, nil)
 	if err != nil {
-		log.Errorf("Http listen and serve error: %+v", err)
+		klog.Errorf("Http listen and serve error: %+v", err)
 		panic(err)
 	} else {
-		log.Info("Http listen and serve started !")
+		klog.Info("Http listen and serve started !")
 	}
 }
 
 //Start - Starts the required http server to start the probe to respond.
-func Start(port string, log log.Logger) {
-	go startAsync(port, log)
+func Start(port string) {
+	go startAsync(port)
 }
 
 // InitAndStart - Initialize the default probes and starts the http listening port.
-func InitAndStart(port string, condition *bool, log log.Logger) {
+func InitAndStart(port string, condition *bool) {
 	InitHealthProbe(condition)
-	log.Infof("Initialized health probe on port %s", port)
+	klog.Infof("Initialized health probe on port %s", port)
 	// start the probe.
-	Start(port, log)
-	log.Info("Started health probe")
+	Start(port)
+	klog.Info("Started health probe")
 }
diff --git a/pkg/stats/stats.go b/pkg/stats/stats.go
index 47baae6d..19dc213b 100644
--- a/pkg/stats/stats.go
+++ b/pkg/stats/stats.go
@@ -4,7 +4,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/golang/glog"
+	"k8s.io/klog"
 )
 
 var GlobalStats map[StatsType]time.Duration
@@ -78,14 +78,14 @@ func Print(key StatsType) {
 	Mutex.RLock()
 	defer Mutex.RUnlock()
 
-	glog.Infof("%s: %s", key, GlobalStats[key])
+	klog.Infof("%s: %s", key, GlobalStats[key])
 }
 
 func PrintCount(key StatsType) {
 	Mutex.RLock()
 	defer Mutex.RUnlock()
 
-	glog.Infof("%s: %d", key, CountStats[key])
+	klog.Infof("%s: %d", key, CountStats[key])
 }
 
 func UpdateCount(key StatsType, val int) {
@@ -95,7 +95,7 @@ func UpdateCount(key StatsType, val int) {
 }
 
 func PrintSync() {
-	glog.Infof("** Stats collected **")
+	klog.Infof("** Stats collected **")
 	if GlobalStats != nil {
 		//first we list the
 		Print(PodList)
@@ -124,7 +124,7 @@ func PrintSync() {
 		Print(EventRecord)
 		Print(Total)
 	}
-	glog.Infof("*********************")
+	klog.Infof("*********************")
 }
 
 func GetAll() map[StatsType]time.Duration {
@@ -132,12 +132,3 @@ func GetAll() map[StatsType]time.Duration {
 	defer Mutex.RUnlock()
 	return GlobalStats
 }
-
-/*
-//More sophisticated stats
-type MICStat struct {
-	msg        string
-	timeTaken  time.Duration
-	operations int64
-}
-*/


Test patch:
diff --git a/pkg/mic/mic_test.go b/pkg/mic/mic_test.go
index 162b7770..b38b93fa 100644
--- a/pkg/mic/mic_test.go
+++ b/pkg/mic/mic_test.go
@@ -12,8 +12,6 @@ import (
 	"github.com/Azure/aad-pod-identity/pkg/config"
 	"github.com/Azure/aad-pod-identity/pkg/metrics"
 
-	"github.com/golang/glog"
-
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute"
 
 	cp "github.com/Azure/aad-pod-identity/pkg/cloudprovider"
@@ -22,6 +20,7 @@ import (
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/rest"
+	"k8s.io/klog"
 )
 
 /****************** CLOUD PROVIDER MOCK ****************************/
@@ -200,10 +199,10 @@ func (c *TestCloudClient) CompareMSI(nodeName string, userIDs []string) bool {
 
 func (c *TestCloudClient) PrintMSI() {
 	for key, val := range c.ListMSI() {
-		glog.Infof("\nNode name: %s", key)
+		klog.Infof("\nNode name: %s", key)
 		if val != nil {
 			for i, id := range *val {
-				glog.Infof("%d) %s", i, id)
+				klog.Infof("%d) %s", i, id)
 			}
 		}
 	}
@@ -271,7 +270,7 @@ func NewTestPodClient() *TestPodClient {
 }
 
 func (c *TestPodClient) Start(exit <-chan struct{}) {
-	glog.Info("Start called from the test interface")
+	klog.Info("Start called from the test interface")
 }
 
 func (c *TestPodClient) GetPods() ([]*corev1.Pod, error) {
@@ -577,7 +576,7 @@ func (c *TestEventRecorder) Validate(e *LastEvent) bool {
 	c.mu.Unlock()
 
 	if t != e.Type || r != e.Reason || m != e.Message {
-		glog.Errorf("event mismatch. expected - (t:%s, r:%s, m:%s). got - (t:%s, r:%s, m:%s)", e.Type, e.Reason, e.Message, t, r, m)
+		klog.Errorf("event mismatch. expected - (t:%s, r:%s, m:%s). got - (t:%s, r:%s, m:%s)", e.Type, e.Reason, e.Message, t, r, m)
 		return false
 	}
 	return true
@@ -742,7 +741,7 @@ func TestSimpleMICClient(t *testing.T) {
 	testPass := false
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 
@@ -770,7 +769,7 @@ func TestSimpleMICClient(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Fatalf("list assigned failed")
 	}
 
@@ -798,7 +797,7 @@ func TestSimpleMICClient(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Fatalf("list assigned failed")
 	}
 
@@ -881,7 +880,7 @@ func TestAddDelMICClient(t *testing.T) {
 
 	//One id should be left around. Rest should be removed
 	if gotLen != expectedLen {
-		glog.Errorf("Expected len: %d. Got: %d", expectedLen, gotLen)
+		klog.Errorf("Expected len: %d. Got: %d", expectedLen, gotLen)
 		t.Fatalf("Add and delete id at same time mismatch")
 	}
 
@@ -908,7 +907,7 @@ func TestAddDelMICClient(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Fatalf("list assigned failed")
 	}
 
@@ -916,13 +915,13 @@ func TestAddDelMICClient(t *testing.T) {
 	gotLen = len(*listAssignedIDs)
 	//One id should be left around. Rest should be removed
 	if gotLen != expectedLen {
-		glog.Errorf("Expected len: %d. Got: %d", expectedLen, gotLen)
+		klog.Errorf("Expected len: %d. Got: %d", expectedLen, gotLen)
 		t.Fatalf("Add and delete id at same time mismatch")
 	} else {
 		gotID := (*listAssignedIDs)[0].Name
 		expectedID := "test-pod3-default-test-id3"
 		if gotID != expectedID {
-			glog.Errorf("Expected %s. Got: %s", expectedID, gotID)
+			klog.Errorf("Expected %s. Got: %s", expectedID, gotID)
 			t.Fatalf("Add and delete id at same time. Found wrong id")
 		}
 	}
@@ -971,7 +970,7 @@ func TestMicAddDelVMSS(t *testing.T) {
 	}
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 3) {
@@ -993,7 +992,7 @@ func TestMicAddDelVMSS(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 2) {
@@ -1016,7 +1015,7 @@ func TestMicAddDelVMSS(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
@@ -1059,7 +1058,7 @@ func TestMICStateFlow(t *testing.T) {
 
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
@@ -1082,7 +1081,7 @@ func TestMICStateFlow(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
@@ -1109,7 +1108,7 @@ func TestMICStateFlow(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 2) {
@@ -1137,7 +1136,7 @@ func TestMICStateFlow(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 0) {
@@ -1171,7 +1170,7 @@ func TestForceNamespaced(t *testing.T) {
 	}
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
@@ -1195,7 +1194,7 @@ func TestForceNamespaced(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 2) {
@@ -1241,7 +1240,7 @@ func TestSyncRetryLoop(t *testing.T) {
 	}
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
@@ -1263,7 +1262,7 @@ func TestSyncRetryLoop(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
@@ -1280,7 +1279,7 @@ func TestSyncRetryLoop(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 0) {
@@ -1318,7 +1317,7 @@ func TestSyncNodeNotFound(t *testing.T) {
 
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 10) {
@@ -1347,7 +1346,7 @@ func TestSyncNodeNotFound(t *testing.T) {
 
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 6) {
@@ -1390,7 +1389,7 @@ func TestProcessingTimeForScale(t *testing.T) {
 
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 20000) {
@@ -1407,7 +1406,7 @@ func TestProcessingTimeForScale(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 10000) {
@@ -1477,7 +1476,7 @@ func TestMicAddDelVMSSwithImmutableIdentities(t *testing.T) {
 	}
 	listAssignedIDs, err := crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 3) {
@@ -1499,7 +1498,7 @@ func TestMicAddDelVMSSwithImmutableIdentities(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 2) {
@@ -1522,7 +1521,7 @@ func TestMicAddDelVMSSwithImmutableIdentities(t *testing.T) {
 	}
 	listAssignedIDs, err = crdClient.ListAssignedIDs()
 	if err != nil {
-		glog.Error(err)
+		klog.Error(err)
 		t.Errorf("list assigned failed")
 	}
 	if !(len(*listAssignedIDs) == 1) {
diff --git a/pkg/nmi/server/server_test.go b/pkg/nmi/server/server_test.go
index a876fc11..ddd1ca1d 100644
--- a/pkg/nmi/server/server_test.go
+++ b/pkg/nmi/server/server_test.go
@@ -8,7 +8,7 @@ import (
 	auth "github.com/Azure/aad-pod-identity/pkg/auth"
 	"github.com/Azure/aad-pod-identity/pkg/k8s"
 	"github.com/Azure/aad-pod-identity/pkg/metrics"
-	log "github.com/sirupsen/logrus"
+
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/fake"
@@ -43,6 +43,5 @@ func TestGetTokenForMatchingIDBySP(t *testing.T) {
 		},
 	}
 	podIDs := []aadpodid.AzureIdentity{podID}
-	logger := log.WithError(nil)
-	getTokenForMatchingID(kubeClient, logger, podID.Spec.ClientID, "https://management.azure.com/", podIDs)
+	getTokenForMatchingID(kubeClient, podID.Spec.ClientID, "https://management.azure.com/", podIDs)
 }
diff --git a/pkg/pod/pod_test.go b/pkg/pod/pod_test.go
index 93961929..6e02f741 100644
--- a/pkg/pod/pod_test.go
+++ b/pkg/pod/pod_test.go
@@ -5,9 +5,9 @@ import (
 
 	aadpodid "github.com/Azure/aad-pod-identity/pkg/apis/aadpodidentity/v1"
 
-	"github.com/golang/glog"
 	corev1 "k8s.io/api/core/v1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/klog"
 )
 
 type TestPodClient struct {
@@ -22,7 +22,7 @@ func NewTestPodClient() *TestPodClient {
 }
 
 func (c TestPodClient) Start(exit <-chan struct{}) {
-	glog.Info("Start called from the test interface")
+	klog.Info("Start called from the test interface")
 }
 
 func (c TestPodClient) GetPods() (pods []*corev1.Pod, err error) {
@@ -34,7 +34,7 @@ func (c *TestPodClient) AddPod(podName string, podNs string, nodeName string, bi
 	labels := make(map[string]string)
 	labels[aadpodid.CRDLabelKey] = binding
 	pod := &corev1.Pod{
-		ObjectMeta: v1.ObjectMeta{
+		ObjectMeta: metav1.ObjectMeta{
 			Name:      podName,
 			Namespace: podNs,
 			Labels:    labels,
@@ -77,7 +77,7 @@ func TestIsPodExcepted(t *testing.T) {
 			podLabels: map[string]string{"foo": "except"},
 			exceptionList: []aadpodid.AzurePodIdentityException{
 				{
-					ObjectMeta: v1.ObjectMeta{
+					ObjectMeta: metav1.ObjectMeta{
 						Name: "exception1",
 					},
 					Spec: aadpodid.AzurePodIdentityExceptionSpec{
@@ -91,7 +91,7 @@ func TestIsPodExcepted(t *testing.T) {
 			podLabels: map[string]string{"foo": "except"},
 			exceptionList: []aadpodid.AzurePodIdentityException{
 				{
-					ObjectMeta: v1.ObjectMeta{
+					ObjectMeta: metav1.ObjectMeta{
 						Name: "exception1",
 					},
 					Spec: aadpodid.AzurePodIdentityExceptionSpec{
@@ -99,7 +99,7 @@ func TestIsPodExcepted(t *testing.T) {
 					},
 				},
 				{
-					ObjectMeta: v1.ObjectMeta{
+					ObjectMeta: metav1.ObjectMeta{
 						Name: "exception2",
 					},
 					Spec: aadpodid.AzurePodIdentityExceptionSpec{
diff --git a/pkg/stats/stats_test.go b/pkg/stats/stats_test.go
index c3c11fb2..1545244c 100644
--- a/pkg/stats/stats_test.go
+++ b/pkg/stats/stats_test.go
@@ -7,11 +7,9 @@ import (
 	"time"
 
 	"github.com/Azure/aad-pod-identity/pkg/stats"
-	"github.com/golang/glog"
 )
 
 func TestBasics(t *testing.T) {
-	glog.Infof("Test started")
 	validateMap := make(map[stats.StatsType]time.Duration)
 	stats.Init()
 	stats.Put(stats.Total, time.Second*20)
@@ -34,7 +32,6 @@ func TestBasics(t *testing.T) {
 }
 
 func TestConcurrency(t *testing.T) {
-	glog.Infof("Concurrency test starting")
 	stats.Init()
 	var wg sync.WaitGroup
 	var startWg sync.WaitGroup
diff --git a/test/e2e/identityvalidator/identityvalidator.go b/test/e2e/identityvalidator/identityvalidator.go
index 1a34d2bf..7adcf61c 100644
--- a/test/e2e/identityvalidator/identityvalidator.go
+++ b/test/e2e/identityvalidator/identityvalidator.go
@@ -6,6 +6,7 @@ import (
 	"os"
 
 	"github.com/pkg/errors"
+	"k8s.io/klog"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute"
 	"github.com/Azure/azure-sdk-for-go/services/keyvault/2016-10-01/keyvault"
@@ -13,7 +14,6 @@ import (
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
-	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 )
 
@@ -33,40 +33,34 @@ func main() {
 	podnamespace := os.Getenv("E2E_TEST_POD_NAMESPACE")
 	podip := os.Getenv("E2E_TEST_POD_IP")
 
-	log.Infof("Starting identity validator pod %s/%s %s", podnamespace, podname, podip)
-
-	logger := log.WithFields(log.Fields{
-		"podnamespace": podnamespace,
-		"podname":      podname,
-		"podip":        podip,
-	})
+	klog.Infof("Starting identity validator pod %s/%s %s", podnamespace, podname, podip)
 
 	msiEndpoint, err := adal.GetMSIVMEndpoint()
 	if err != nil {
-		logger.Fatalf("Failed to get msiEndpoint: %+v", err)
+		klog.Fatalf("Failed to get msiEndpoint: %+v", err)
 	}
-	logger.Infof("Successfully obtain MSIEndpoint: %s\n", msiEndpoint)
+	klog.Infof("Successfully obtain MSIEndpoint: %s\n", msiEndpoint)
 
 	if *keyvaultName != "" && *keyvaultSecretName != "" {
 		// Test if the pod identity is set up correctly
-		if err := testUserAssignedIdentityOnPod(logger, msiEndpoint, *identityClientID, *keyvaultName, *keyvaultSecretName, *keyvaultSecretVersion); err != nil {
-			logger.Fatalf("testUserAssignedIdentityOnPod failed, %+v", err)
+		if err := testUserAssignedIdentityOnPod(msiEndpoint, *identityClientID, *keyvaultName, *keyvaultSecretName, *keyvaultSecretVersion); err != nil {
+			klog.Fatalf("testUserAssignedIdentityOnPod failed, %+v", err)
 		}
 	} else {
 		// Test if the cluster-wide user assigned identity is set up correctly
-		if err := testClusterWideUserAssignedIdentity(logger, msiEndpoint, *subscriptionID, *resourceGroup, *identityClientID); err != nil {
-			logger.Fatalf("testClusterWideUserAssignedIdentity failed, %+v", err)
+		if err := testClusterWideUserAssignedIdentity(msiEndpoint, *subscriptionID, *resourceGroup, *identityClientID); err != nil {
+			klog.Fatalf("testClusterWideUserAssignedIdentity failed, %+v", err)
 		}
 	}
 
 	// Test if a service principal token can be obtained when using a system assigned identity
-	if t1, err := testSystemAssignedIdentity(logger, msiEndpoint); err != nil || t1 == nil {
-		logger.Fatalf("testSystemAssignedIdentity failed, %+v", err)
+	if t1, err := testSystemAssignedIdentity(msiEndpoint); err != nil || t1 == nil {
+		klog.Fatalf("testSystemAssignedIdentity failed, %+v", err)
 	}
 }
 
 // testClusterWideUserAssignedIdentity will verify whether cluster-wide user assigned identity is working properly
-func testClusterWideUserAssignedIdentity(logger *log.Entry, msiEndpoint, subscriptionID, resourceGroup, identityClientID string) error {
+func testClusterWideUserAssignedIdentity(msiEndpoint, subscriptionID, resourceGroup, identityClientID string) error {
 	os.Setenv("AZURE_CLIENT_ID", identityClientID)
 	defer os.Unsetenv("AZURE_CLIENT_ID")
 	token, err := adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, azure.PublicCloud.ResourceManagerEndpoint, identityClientID)
@@ -81,12 +75,12 @@ func testClusterWideUserAssignedIdentity(logger *log.Entry, msiEndpoint, subscri
 		return errors.Wrapf(err, "Failed to verify cluster-wide user assigned identity")
 	}
 
-	logger.Infof("Successfully verified cluster-wide user assigned identity. VM count: %d", len(vmlist.Values()))
+	klog.Infof("Successfully verified cluster-wide user assigned identity. VM count: %d", len(vmlist.Values()))
 	return nil
 }
 
 // testUserAssignedIdentityOnPod will verify whether a pod identity is working properly
-func testUserAssignedIdentityOnPod(logger *log.Entry, msiEndpoint, identityClientID, keyvaultName, keyvaultSecretName, keyvaultSecretVersion string) error {
+func testUserAssignedIdentityOnPod(msiEndpoint, identityClientID, keyvaultName, keyvaultSecretName, keyvaultSecretVersion string) error {
 	// When new authorizer is created, azure-sdk-for-go  tries to create dataplane authorizer using MSI. It checks the AZURE_CLIENT_ID to get the client id
 	// for the user assigned identity. If client id not found, then NewServicePrincipalTokenFromMSI is invoked instead of using the actual
 	// user assigned identity. Setting this env var ensures we validate GetSecret using the desired user assigned identity.
@@ -99,18 +93,18 @@ func testUserAssignedIdentityOnPod(logger *log.Entry, msiEndpoint, identityClien
 		keyClient.Authorizer = authorizer
 	}
 
-	logger.Infof("%s %s %s\n", keyvaultName, keyvaultSecretName, keyvaultSecretVersion)
+	klog.Infof("%s %s %s\n", keyvaultName, keyvaultSecretName, keyvaultSecretVersion)
 	secret, err := keyClient.GetSecret(context.Background(), fmt.Sprintf("https://%s.vault.azure.net", keyvaultName), keyvaultSecretName, keyvaultSecretVersion)
 	if err != nil || *secret.Value == "" {
 		return errors.Wrapf(err, "Failed to verify user assigned identity on pod")
 	}
 
-	logger.Infof("Successfully verified user assigned identity on pod")
+	klog.Infof("Successfully verified user assigned identity on pod")
 	return nil
 }
 
 // testMSIEndpoint will return a service principal token obtained through a system assigned identity
-func testSystemAssignedIdentity(logger *log.Entry, msiEndpoint string) (*adal.Token, error) {
+func testSystemAssignedIdentity(msiEndpoint string) (*adal.Token, error) {
 	spt, err := adal.NewServicePrincipalTokenFromMSI(msiEndpoint, azure.PublicCloud.ResourceManagerEndpoint)
 	if err != nil {
 		return nil, errors.Wrapf(err, "Failed to acquire a token using the MSI VM extension")
@@ -125,6 +119,6 @@ func testSystemAssignedIdentity(logger *log.Entry, msiEndpoint string) (*adal.To
 		return nil, errors.Errorf("No token found, MSI VM extension, msiEndpoint(%s)", msiEndpoint)
 	}
 
-	logger.Infof("Successfully acquired a token using the MSI, msiEndpoint(%s)", msiEndpoint)
+	klog.Infof("Successfully acquired a token using the MSI, msiEndpoint(%s)", msiEndpoint)
 	return &token, nil
 }