diff --git a/internal/k8s/appprotect_dos.go b/internal/k8s/appprotect_dos.go
index fe9754897..d0cd0dea7 100644
--- a/internal/k8s/appprotect_dos.go
+++ b/internal/k8s/appprotect_dos.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/golang/glog"
 	"github.com/nginxinc/kubernetes-ingress/internal/k8s/appprotectdos"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	"github.com/nginxinc/kubernetes-ingress/pkg/apis/dos/v1beta1"
 	api_v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -16,19 +16,19 @@ func createAppProtectDosPolicyHandlers(lbc *LoadBalancerController) cache.Resour
 	handlers := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			pol := obj.(*unstructured.Unstructured)
-			glog.V(3).Infof("Adding AppProtectDosPolicy: %v", pol.GetName())
+			nl.Debugf(lbc.logger, "Adding AppProtectDosPolicy: %v", pol.GetName())
 			lbc.AddSyncQueue(pol)
 		},
 		UpdateFunc: func(oldObj, obj interface{}) {
 			oldPol := oldObj.(*unstructured.Unstructured)
 			newPol := obj.(*unstructured.Unstructured)
-			different, err := areResourcesDifferent(oldPol, newPol)
+			different, err := areResourcesDifferent(lbc.logger, oldPol, newPol)
 			if err != nil {
-				glog.V(3).Infof("Error when comparing policy %v", err)
+				nl.Debugf(lbc.logger, "Error when comparing policy %v", err)
 				lbc.AddSyncQueue(newPol)
 			}
 			if different {
-				glog.V(3).Infof("ApDosPolicy %v changed, syncing", oldPol.GetName())
+				nl.Debugf(lbc.logger, "ApDosPolicy %v changed, syncing", oldPol.GetName())
 				lbc.AddSyncQueue(newPol)
 			}
 		},
@@ -43,19 +43,19 @@ func createAppProtectDosLogConfHandlers(lbc *LoadBalancerController) cache.Resou
 	handlers := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			conf := obj.(*unstructured.Unstructured)
-			glog.V(3).Infof("Adding AppProtectDosLogConf: %v", conf.GetName())
+			nl.Debugf(lbc.logger, "Adding AppProtectDosLogConf: %v", conf.GetName())
 			lbc.AddSyncQueue(conf)
 		},
 		UpdateFunc: func(oldObj, obj interface{}) {
 			oldConf := oldObj.(*unstructured.Unstructured)
 			newConf := obj.(*unstructured.Unstructured)
-			different, err := areResourcesDifferent(oldConf, newConf)
+			different, err := areResourcesDifferent(lbc.logger, oldConf, newConf)
 			if err != nil {
-				glog.V(3).Infof("Error when comparing DosLogConfs %v", err)
+				nl.Debugf(lbc.logger, "Error when comparing DosLogConfs %v", err)
 				lbc.AddSyncQueue(newConf)
 			}
 			if different {
-				glog.V(3).Infof("ApDosLogConf %v changed, syncing", oldConf.GetName())
+				nl.Debugf(lbc.logger, "ApDosLogConf %v changed, syncing", oldConf.GetName())
 				lbc.AddSyncQueue(newConf)
 			}
 		},
@@ -70,7 +70,7 @@ func createAppProtectDosProtectedResourceHandlers(lbc *LoadBalancerController) c
 	handlers := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			conf := obj.(*v1beta1.DosProtectedResource)
-			glog.V(3).Infof("Adding DosProtectedResource: %v", conf.GetName())
+			nl.Debugf(lbc.logger, "Adding DosProtectedResource: %v", conf.GetName())
 			lbc.AddSyncQueue(conf)
 		},
 		UpdateFunc: func(oldObj, obj interface{}) {
@@ -78,7 +78,7 @@ func createAppProtectDosProtectedResourceHandlers(lbc *LoadBalancerController) c
 			newConf := obj.(*v1beta1.DosProtectedResource)
 
 			if !reflect.DeepEqual(oldConf.Spec, newConf.Spec) {
-				glog.V(3).Infof("DosProtectedResource %v changed, syncing", oldConf.GetName())
+				nl.Debugf(lbc.logger, "DosProtectedResource %v changed, syncing", oldConf.GetName())
 				lbc.AddSyncQueue(newConf)
 			}
 		},
@@ -118,7 +118,7 @@ func (nsi *namespacedInformer) addAppProtectDosProtectedResourceHandler(handlers
 
 func (lbc *LoadBalancerController) syncAppProtectDosPolicy(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing AppProtectDosPolicy %v", key)
+	nl.Debugf(lbc.logger, "Syncing AppProtectDosPolicy %v", key)
 	var obj interface{}
 	var polExists bool
 	var err error
@@ -134,10 +134,10 @@ func (lbc *LoadBalancerController) syncAppProtectDosPolicy(task task) {
 	var problems []appprotectdos.Problem
 
 	if !polExists {
-		glog.V(2).Infof("Deleting APDosPolicy: %v\n", key)
+		nl.Debugf(lbc.logger, "Deleting APDosPolicy: %v\n", key)
 		changes, problems = lbc.dosConfiguration.DeletePolicy(key)
 	} else {
-		glog.V(2).Infof("Adding or Updating APDosPolicy: %v\n", key)
+		nl.Debugf(lbc.logger, "Adding or Updating APDosPolicy: %v\n", key)
 		changes, problems = lbc.dosConfiguration.AddOrUpdatePolicy(obj.(*unstructured.Unstructured))
 	}
 
@@ -147,7 +147,7 @@ func (lbc *LoadBalancerController) syncAppProtectDosPolicy(task task) {
 
 func (lbc *LoadBalancerController) syncAppProtectDosLogConf(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing APDosLogConf %v", key)
+	nl.Debugf(lbc.logger, "Syncing APDosLogConf %v", key)
 	var obj interface{}
 	var confExists bool
 	var err error
@@ -163,10 +163,10 @@ func (lbc *LoadBalancerController) syncAppProtectDosLogConf(task task) {
 	var problems []appprotectdos.Problem
 
 	if !confExists {
-		glog.V(2).Infof("Deleting APDosLogConf: %v\n", key)
+		nl.Debugf(lbc.logger, "Deleting APDosLogConf: %v\n", key)
 		changes, problems = lbc.dosConfiguration.DeleteLogConf(key)
 	} else {
-		glog.V(2).Infof("Adding or Updating APDosLogConf: %v\n", key)
+		nl.Debugf(lbc.logger, "Adding or Updating APDosLogConf: %v\n", key)
 		changes, problems = lbc.dosConfiguration.AddOrUpdateLogConf(obj.(*unstructured.Unstructured))
 	}
 
@@ -176,7 +176,7 @@ func (lbc *LoadBalancerController) syncAppProtectDosLogConf(task task) {
 
 func (lbc *LoadBalancerController) syncDosProtectedResource(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing DosProtectedResource %v", key)
+	nl.Debugf(lbc.logger, "Syncing DosProtectedResource %v", key)
 	var obj interface{}
 	var confExists bool
 	var err error
@@ -192,10 +192,10 @@ func (lbc *LoadBalancerController) syncDosProtectedResource(task task) {
 	var problems []appprotectdos.Problem
 
 	if confExists {
-		glog.V(2).Infof("Adding or Updating DosProtectedResource: %v\n", key)
+		nl.Debugf(lbc.logger, "Adding or Updating DosProtectedResource: %v\n", key)
 		changes, problems = lbc.dosConfiguration.AddOrUpdateDosProtectedResource(obj.(*v1beta1.DosProtectedResource))
 	} else {
-		glog.V(2).Infof("Deleting DosProtectedResource: %v\n", key)
+		nl.Debugf(lbc.logger, "Deleting DosProtectedResource: %v\n", key)
 		changes, problems = lbc.dosConfiguration.DeleteProtectedResource(key)
 	}
 
@@ -204,13 +204,13 @@ func (lbc *LoadBalancerController) syncDosProtectedResource(task task) {
 }
 
 func (lbc *LoadBalancerController) processAppProtectDosChanges(changes []appprotectdos.Change) {
-	glog.V(3).Infof("Processing %v App Protect Dos changes", len(changes))
+	nl.Debugf(lbc.logger, "Processing %v App Protect Dos changes", len(changes))
 
 	for _, c := range changes {
 		if c.Op == appprotectdos.AddOrUpdate {
 			switch impl := c.Resource.(type) {
 			case *appprotectdos.DosProtectedResourceEx:
-				glog.V(3).Infof("handling change UPDATE OR ADD for DOS protected %s/%s", impl.Obj.Namespace, impl.Obj.Name)
+				nl.Debugf(lbc.logger, "handling change UPDATE OR ADD for DOS protected %s/%s", impl.Obj.Namespace, impl.Obj.Name)
 				resources := lbc.configuration.FindResourcesForAppProtectDosProtected(impl.Obj.Namespace, impl.Obj.Name)
 				resourceExes := lbc.createExtendedResources(resources)
 				warnings, err := lbc.configurator.AddOrUpdateResourcesThatUseDosProtected(resourceExes.IngressExes, resourceExes.MergeableIngresses, resourceExes.VirtualServerExes)
@@ -240,7 +240,7 @@ func (lbc *LoadBalancerController) processAppProtectDosChanges(changes []appprot
 				lbc.configurator.DeleteAppProtectDosLogConf(impl.Obj)
 
 			case *appprotectdos.DosProtectedResourceEx:
-				glog.V(3).Infof("handling change DELETE for DOS protected %s/%s", impl.Obj.Namespace, impl.Obj.Name)
+				nl.Debugf(lbc.logger, "handling change DELETE for DOS protected %s/%s", impl.Obj.Namespace, impl.Obj.Name)
 				resources := lbc.configuration.FindResourcesForAppProtectDosProtected(impl.Obj.Namespace, impl.Obj.Name)
 				resourceExes := lbc.createExtendedResources(resources)
 				warnings, err := lbc.configurator.AddOrUpdateResourcesThatUseDosProtected(resourceExes.IngressExes, resourceExes.MergeableIngresses, resourceExes.VirtualServerExes)
@@ -251,7 +251,7 @@ func (lbc *LoadBalancerController) processAppProtectDosChanges(changes []appprot
 }
 
 func (lbc *LoadBalancerController) processAppProtectDosProblems(problems []appprotectdos.Problem) {
-	glog.V(3).Infof("Processing %v App Protect Dos problems", len(problems))
+	nl.Debugf(lbc.logger, "Processing %v App Protect Dos problems", len(problems))
 
 	for _, p := range problems {
 		eventType := api_v1.EventTypeWarning
diff --git a/internal/k8s/appprotect_waf.go b/internal/k8s/appprotect_waf.go
index d313f6a66..57483fd58 100644
--- a/internal/k8s/appprotect_waf.go
+++ b/internal/k8s/appprotect_waf.go
@@ -4,10 +4,10 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/golang/glog"
 	"github.com/nginxinc/kubernetes-ingress/internal/configs"
 	"github.com/nginxinc/kubernetes-ingress/internal/k8s/appprotect"
 	"github.com/nginxinc/kubernetes-ingress/internal/k8s/appprotectcommon"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	conf_v1 "github.com/nginxinc/kubernetes-ingress/pkg/apis/configuration/v1"
 	api_v1 "k8s.io/api/core/v1"
 	networking "k8s.io/api/networking/v1"
@@ -19,19 +19,19 @@ func createAppProtectPolicyHandlers(lbc *LoadBalancerController) cache.ResourceE
 	handlers := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			pol := obj.(*unstructured.Unstructured)
-			glog.V(3).Infof("Adding AppProtectPolicy: %v", pol.GetName())
+			nl.Debugf(lbc.logger, "Adding AppProtectPolicy: %v", pol.GetName())
 			lbc.AddSyncQueue(pol)
 		},
 		UpdateFunc: func(oldObj, obj interface{}) {
 			oldPol := oldObj.(*unstructured.Unstructured)
 			newPol := obj.(*unstructured.Unstructured)
-			different, err := areResourcesDifferent(oldPol, newPol)
+			different, err := areResourcesDifferent(lbc.logger, oldPol, newPol)
 			if err != nil {
-				glog.V(3).Infof("Error when comparing policy %v", err)
+				nl.Debugf(lbc.logger, "Error when comparing policy %v", err)
 				lbc.AddSyncQueue(newPol)
 			}
 			if different {
-				glog.V(3).Infof("ApPolicy %v changed, syncing", oldPol.GetName())
+				nl.Debugf(lbc.logger, "ApPolicy %v changed, syncing", oldPol.GetName())
 				lbc.AddSyncQueue(newPol)
 			}
 		},
@@ -46,19 +46,19 @@ func createAppProtectLogConfHandlers(lbc *LoadBalancerController) cache.Resource
 	handlers := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			conf := obj.(*unstructured.Unstructured)
-			glog.V(3).Infof("Adding AppProtectLogConf: %v", conf.GetName())
+			nl.Debugf(lbc.logger, "Adding AppProtectLogConf: %v", conf.GetName())
 			lbc.AddSyncQueue(conf)
 		},
 		UpdateFunc: func(oldObj, obj interface{}) {
 			oldConf := oldObj.(*unstructured.Unstructured)
 			newConf := obj.(*unstructured.Unstructured)
-			different, err := areResourcesDifferent(oldConf, newConf)
+			different, err := areResourcesDifferent(lbc.logger, oldConf, newConf)
 			if err != nil {
-				glog.V(3).Infof("Error when comparing LogConfs %v", err)
+				nl.Debugf(lbc.logger, "Error when comparing LogConfs %v", err)
 				lbc.AddSyncQueue(newConf)
 			}
 			if different {
-				glog.V(3).Infof("ApLogConf %v changed, syncing", oldConf.GetName())
+				nl.Debugf(lbc.logger, "ApLogConf %v changed, syncing", oldConf.GetName())
 				lbc.AddSyncQueue(newConf)
 			}
 		},
@@ -73,19 +73,19 @@ func createAppProtectUserSigHandlers(lbc *LoadBalancerController) cache.Resource
 	handlers := cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			sig := obj.(*unstructured.Unstructured)
-			glog.V(3).Infof("Adding AppProtectUserSig: %v", sig.GetName())
+			nl.Debugf(lbc.logger, "Adding AppProtectUserSig: %v", sig.GetName())
 			lbc.AddSyncQueue(sig)
 		},
 		UpdateFunc: func(oldObj, obj interface{}) {
 			oldSig := oldObj.(*unstructured.Unstructured)
 			newSig := obj.(*unstructured.Unstructured)
-			different, err := areResourcesDifferent(oldSig, newSig)
+			different, err := areResourcesDifferent(lbc.logger, oldSig, newSig)
 			if err != nil {
-				glog.V(3).Infof("Error when comparing UserSigs %v", err)
+				nl.Debugf(lbc.logger, "Error when comparing UserSigs %v", err)
 				lbc.AddSyncQueue(newSig)
 			}
 			if different {
-				glog.V(3).Infof("ApUserSig %v changed, syncing", oldSig.GetName())
+				nl.Debugf(lbc.logger, "ApUserSig %v changed, syncing", oldSig.GetName())
 				lbc.AddSyncQueue(newSig)
 			}
 		},
@@ -125,7 +125,7 @@ func (nsi *namespacedInformer) addAppProtectUserSigHandler(handlers cache.Resour
 
 func (lbc *LoadBalancerController) syncAppProtectPolicy(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing AppProtectPolicy %v", key)
+	nl.Debugf(lbc.logger, "Syncing AppProtectPolicy %v", key)
 
 	var obj interface{}
 	var polExists bool
@@ -142,11 +142,11 @@ func (lbc *LoadBalancerController) syncAppProtectPolicy(task task) {
 	var problems []appprotect.Problem
 
 	if !polExists {
-		glog.V(2).Infof("Deleting AppProtectPolicy: %v\n", key)
+		nl.Debugf(lbc.logger, "Deleting AppProtectPolicy: %v\n", key)
 
 		changes, problems = lbc.appProtectConfiguration.DeletePolicy(key)
 	} else {
-		glog.V(2).Infof("Adding or Updating AppProtectPolicy: %v\n", key)
+		nl.Debugf(lbc.logger, "Adding or Updating AppProtectPolicy: %v\n", key)
 
 		changes, problems = lbc.appProtectConfiguration.AddOrUpdatePolicy(obj.(*unstructured.Unstructured))
 	}
@@ -157,7 +157,7 @@ func (lbc *LoadBalancerController) syncAppProtectPolicy(task task) {
 
 func (lbc *LoadBalancerController) syncAppProtectLogConf(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing AppProtectLogConf %v", key)
+	nl.Debugf(lbc.logger, "Syncing AppProtectLogConf %v", key)
 	var obj interface{}
 	var confExists bool
 	var err error
@@ -173,11 +173,11 @@ func (lbc *LoadBalancerController) syncAppProtectLogConf(task task) {
 	var problems []appprotect.Problem
 
 	if !confExists {
-		glog.V(2).Infof("Deleting AppProtectLogConf: %v\n", key)
+		nl.Debugf(lbc.logger, "Deleting AppProtectLogConf: %v\n", key)
 
 		changes, problems = lbc.appProtectConfiguration.DeleteLogConf(key)
 	} else {
-		glog.V(2).Infof("Adding or Updating AppProtectLogConf: %v\n", key)
+		nl.Debugf(lbc.logger, "Adding or Updating AppProtectLogConf: %v\n", key)
 
 		changes, problems = lbc.appProtectConfiguration.AddOrUpdateLogConf(obj.(*unstructured.Unstructured))
 	}
@@ -188,7 +188,7 @@ func (lbc *LoadBalancerController) syncAppProtectLogConf(task task) {
 
 func (lbc *LoadBalancerController) syncAppProtectUserSig(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing AppProtectUserSig %v", key)
+	nl.Debugf(lbc.logger, "Syncing AppProtectUserSig %v", key)
 	var obj interface{}
 	var sigExists bool
 	var err error
@@ -204,11 +204,11 @@ func (lbc *LoadBalancerController) syncAppProtectUserSig(task task) {
 	var problems []appprotect.Problem
 
 	if !sigExists {
-		glog.V(2).Infof("Deleting AppProtectUserSig: %v\n", key)
+		nl.Debugf(lbc.logger, "Deleting AppProtectUserSig: %v\n", key)
 
 		change, problems = lbc.appProtectConfiguration.DeleteUserSig(key)
 	} else {
-		glog.V(2).Infof("Adding or Updating AppProtectUserSig: %v\n", key)
+		nl.Debugf(lbc.logger, "Adding or Updating AppProtectUserSig: %v\n", key)
 
 		change, problems = lbc.appProtectConfiguration.AddOrUpdateUserSig(obj.(*unstructured.Unstructured))
 	}
@@ -353,7 +353,7 @@ func (lbc *LoadBalancerController) getAppProtectPolicy(ing *networking.Ingress)
 }
 
 func (lbc *LoadBalancerController) processAppProtectChanges(changes []appprotect.Change) {
-	glog.V(3).Infof("Processing %v App Protect changes", len(changes))
+	nl.Debugf(lbc.logger, "Processing %v App Protect changes", len(changes))
 
 	for _, c := range changes {
 		if c.Op == appprotect.AddOrUpdate {
@@ -463,13 +463,13 @@ func (lbc *LoadBalancerController) processAppProtectUserSigChange(change appprot
 
 	warnings, err := lbc.configurator.RefreshAppProtectUserSigs(change.UserSigs, delPols, allIngExes, allMergeableIngresses, allVsExes)
 	if err != nil {
-		glog.Errorf("Error when refreshing App Protect Policy User defined signatures: %v", err)
+		nl.Errorf(lbc.logger, "Error when refreshing App Protect Policy User defined signatures: %v", err)
 	}
 	lbc.updateResourcesStatusAndEvents(allResources, warnings, err)
 }
 
 func (lbc *LoadBalancerController) processAppProtectProblems(problems []appprotect.Problem) {
-	glog.V(3).Infof("Processing %v App Protect problems", len(problems))
+	nl.Debugf(lbc.logger, "Processing %v App Protect problems", len(problems))
 
 	for _, p := range problems {
 		eventType := api_v1.EventTypeWarning
@@ -479,7 +479,7 @@ func (lbc *LoadBalancerController) processAppProtectProblems(problems []appprote
 
 func (lbc *LoadBalancerController) cleanupUnwatchedAppWafResources(nsi *namespacedInformer) {
 	for _, obj := range nsi.appProtectPolicyLister.List() {
-		glog.V(3).Infof("Cleaning up unwatched appprotect policies in namespace: %v", nsi.namespace)
+		nl.Debugf(lbc.logger, "Cleaning up unwatched appprotect policies in namespace: %v", nsi.namespace)
 		appPol := obj.((*unstructured.Unstructured))
 		namespace := appPol.GetNamespace()
 		name := appPol.GetName()
@@ -489,7 +489,7 @@ func (lbc *LoadBalancerController) cleanupUnwatchedAppWafResources(nsi *namespac
 		lbc.processAppProtectProblems(problems)
 	}
 	for _, obj := range nsi.appProtectLogConfLister.List() {
-		glog.V(3).Infof("Cleaning up unwatched approtect logconfs in namespace: %v", nsi.namespace)
+		nl.Debugf(lbc.logger, "Cleaning up unwatched approtect logconfs in namespace: %v", nsi.namespace)
 		appLogConf := obj.((*unstructured.Unstructured))
 		namespace := appLogConf.GetNamespace()
 		name := appLogConf.GetName()
@@ -499,7 +499,7 @@ func (lbc *LoadBalancerController) cleanupUnwatchedAppWafResources(nsi *namespac
 		lbc.processAppProtectProblems(problems)
 	}
 	for _, obj := range nsi.appProtectUserSigLister.List() {
-		glog.V(3).Infof("Cleaning up unwatched usersigs in namespace: %v", nsi.namespace)
+		nl.Debugf(lbc.logger, "Cleaning up unwatched usersigs in namespace: %v", nsi.namespace)
 		appUserSig := obj.((*unstructured.Unstructured))
 		namespace := appUserSig.GetNamespace()
 		name := appUserSig.GetName()
diff --git a/internal/k8s/configmap.go b/internal/k8s/configmap.go
index 11431a1fb..e453bbaa5 100644
--- a/internal/k8s/configmap.go
+++ b/internal/k8s/configmap.go
@@ -3,7 +3,7 @@ package k8s
 import (
 	"reflect"
 
-	"github.com/golang/glog"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/client-go/tools/cache"
@@ -15,7 +15,7 @@ func createConfigMapHandlers(lbc *LoadBalancerController, name string) cache.Res
 		AddFunc: func(obj interface{}) {
 			configMap := obj.(*v1.ConfigMap)
 			if configMap.Name == name {
-				glog.V(3).Infof("Adding ConfigMap: %v", configMap.Name)
+				nl.Debugf(lbc.logger, "Adding ConfigMap: %v", configMap.Name)
 				lbc.AddSyncQueue(obj)
 			}
 		},
@@ -24,17 +24,17 @@ func createConfigMapHandlers(lbc *LoadBalancerController, name string) cache.Res
 			if !isConfigMap {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				configMap, ok = deletedState.Obj.(*v1.ConfigMap)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-ConfigMap object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-ConfigMap object: %v", deletedState.Obj)
 					return
 				}
 			}
 			if configMap.Name == name {
-				glog.V(3).Infof("Removing ConfigMap: %v", configMap.Name)
+				nl.Debugf(lbc.logger, "Removing ConfigMap: %v", configMap.Name)
 				lbc.AddSyncQueue(obj)
 			}
 		},
@@ -42,7 +42,7 @@ func createConfigMapHandlers(lbc *LoadBalancerController, name string) cache.Res
 			if !reflect.DeepEqual(old, cur) {
 				configMap := cur.(*v1.ConfigMap)
 				if configMap.Name == name {
-					glog.V(3).Infof("ConfigMap %v changed, syncing", cur.(*v1.ConfigMap).Name)
+					nl.Debugf(lbc.logger, "ConfigMap %v changed, syncing", cur.(*v1.ConfigMap).Name)
 					lbc.AddSyncQueue(cur)
 				}
 			}
@@ -68,7 +68,7 @@ func (lbc *LoadBalancerController) addConfigMapHandler(handlers cache.ResourceEv
 
 func (lbc *LoadBalancerController) syncConfigMap(task task) {
 	key := task.Key
-	glog.V(3).Infof("Syncing configmap %v", key)
+	nl.Debugf(lbc.logger, "Syncing configmap %v", key)
 
 	obj, configExists, err := lbc.configMapLister.GetByKey(key)
 	if err != nil {
@@ -86,12 +86,12 @@ func (lbc *LoadBalancerController) syncConfigMap(task task) {
 	}
 
 	if !lbc.isNginxReady {
-		glog.V(3).Infof("Skipping ConfigMap update because the pod is not ready yet")
+		nl.Debugf(lbc.logger, "Skipping ConfigMap update because the pod is not ready yet")
 		return
 	}
 
 	if lbc.batchSyncEnabled {
-		glog.V(3).Infof("Skipping ConfigMap update because batch sync is on")
+		nl.Debugf(lbc.logger, "Skipping ConfigMap update because batch sync is on")
 		return
 	}
 
diff --git a/internal/k8s/endpoint_slice.go b/internal/k8s/endpoint_slice.go
index 6c691bf5e..37a0eb3cd 100644
--- a/internal/k8s/endpoint_slice.go
+++ b/internal/k8s/endpoint_slice.go
@@ -3,7 +3,7 @@ package k8s
 import (
 	"reflect"
 
-	"github.com/golang/glog"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	discovery_v1 "k8s.io/api/discovery/v1"
 	"k8s.io/client-go/tools/cache"
 )
@@ -13,7 +13,7 @@ func createEndpointSliceHandlers(lbc *LoadBalancerController) cache.ResourceEven
 	return cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			endpointSlice := obj.(*discovery_v1.EndpointSlice)
-			glog.V(3).Infof("Adding EndpointSlice: %v", endpointSlice.Name)
+			nl.Debugf(lbc.logger, "Adding EndpointSlice: %v", endpointSlice.Name)
 			lbc.AddSyncQueue(obj)
 		},
 		DeleteFunc: func(obj interface{}) {
@@ -21,20 +21,20 @@ func createEndpointSliceHandlers(lbc *LoadBalancerController) cache.ResourceEven
 			if !isEndpointSlice {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				endpointSlice, ok = deletedState.Obj.(*discovery_v1.EndpointSlice)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-EndpointSlice object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-EndpointSlice object: %v", deletedState.Obj)
 					return
 				}
 			}
-			glog.V(3).Infof("Removing EndpointSlice: %v", endpointSlice.Name)
+			nl.Debugf(lbc.logger, "Removing EndpointSlice: %v", endpointSlice.Name)
 			lbc.AddSyncQueue(obj)
 		}, UpdateFunc: func(old, cur interface{}) {
 			if !reflect.DeepEqual(old, cur) {
-				glog.V(3).Infof("EndpointSlice %v changed, syncing", cur.(*discovery_v1.EndpointSlice).Name)
+				nl.Debugf(lbc.logger, "EndpointSlice %v changed, syncing", cur.(*discovery_v1.EndpointSlice).Name)
 				lbc.AddSyncQueue(cur)
 			}
 		},
@@ -86,10 +86,10 @@ func (lbc *LoadBalancerController) syncEndpointSlices(task task) bool {
 		for _, ingEx := range resourceExes.IngressExes {
 			if lbc.ingressRequiresEndpointsUpdate(ingEx, svcName) {
 				resourcesFound = true
-				glog.V(3).Infof("Updating EndpointSlices for %v", resourceExes.IngressExes)
+				nl.Debugf(lbc.logger, "Updating EndpointSlices for %v", resourceExes.IngressExes)
 				err = lbc.configurator.UpdateEndpoints(resourceExes.IngressExes)
 				if err != nil {
-					glog.Errorf("Error updating EndpointSlices for %v: %v", resourceExes.IngressExes, err)
+					nl.Errorf(lbc.logger, "Error updating EndpointSlices for %v: %v", resourceExes.IngressExes, err)
 				}
 				break
 			}
@@ -100,10 +100,10 @@ func (lbc *LoadBalancerController) syncEndpointSlices(task task) bool {
 		for _, mergeableIngresses := range resourceExes.MergeableIngresses {
 			if lbc.mergeableIngressRequiresEndpointsUpdate(mergeableIngresses, svcName) {
 				resourcesFound = true
-				glog.V(3).Infof("Updating EndpointSlices for %v", resourceExes.MergeableIngresses)
+				nl.Debugf(lbc.logger, "Updating EndpointSlices for %v", resourceExes.MergeableIngresses)
 				err = lbc.configurator.UpdateEndpointsMergeableIngress(resourceExes.MergeableIngresses)
 				if err != nil {
-					glog.Errorf("Error updating EndpointSlices for %v: %v", resourceExes.MergeableIngresses, err)
+					nl.Errorf(lbc.logger, "Error updating EndpointSlices for %v: %v", resourceExes.MergeableIngresses, err)
 				}
 				break
 			}
@@ -115,10 +115,10 @@ func (lbc *LoadBalancerController) syncEndpointSlices(task task) bool {
 			for _, vsEx := range resourceExes.VirtualServerExes {
 				if lbc.virtualServerRequiresEndpointsUpdate(vsEx, svcName) {
 					resourcesFound = true
-					glog.V(3).Infof("Updating EndpointSlices for %v", resourceExes.VirtualServerExes)
+					nl.Debugf(lbc.logger, "Updating EndpointSlices for %v", resourceExes.VirtualServerExes)
 					err := lbc.configurator.UpdateEndpointsForVirtualServers(resourceExes.VirtualServerExes)
 					if err != nil {
-						glog.Errorf("Error updating EndpointSlices for %v: %v", resourceExes.VirtualServerExes, err)
+						nl.Errorf(lbc.logger, "Error updating EndpointSlices for %v: %v", resourceExes.VirtualServerExes, err)
 					}
 					break
 				}
@@ -127,10 +127,10 @@ func (lbc *LoadBalancerController) syncEndpointSlices(task task) bool {
 
 		if len(resourceExes.TransportServerExes) > 0 {
 			resourcesFound = true
-			glog.V(3).Infof("Updating EndpointSlices for %v", resourceExes.TransportServerExes)
+			nl.Debugf(lbc.logger, "Updating EndpointSlices for %v", resourceExes.TransportServerExes)
 			err := lbc.configurator.UpdateEndpointsForTransportServers(resourceExes.TransportServerExes)
 			if err != nil {
-				glog.Errorf("Error updating EndpointSlices for %v: %v", resourceExes.TransportServerExes, err)
+				nl.Errorf(lbc.logger, "Error updating EndpointSlices for %v: %v", resourceExes.TransportServerExes, err)
 			}
 		}
 	}
diff --git a/internal/k8s/handlers.go b/internal/k8s/handlers.go
index ff79b38c8..2ea0b6c61 100644
--- a/internal/k8s/handlers.go
+++ b/internal/k8s/handlers.go
@@ -2,12 +2,13 @@ package k8s
 
 import (
 	"fmt"
+	"log/slog"
 	"reflect"
 
 	"github.com/jinzhu/copier"
 
-	"github.com/golang/glog"
 	"github.com/nginxinc/kubernetes-ingress/internal/k8s/secrets"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	v1 "k8s.io/api/core/v1"
 	networking "k8s.io/api/networking/v1"
 	"k8s.io/client-go/tools/cache"
@@ -21,7 +22,7 @@ func createIngressHandlers(lbc *LoadBalancerController) cache.ResourceEventHandl
 	return cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			ingress := obj.(*networking.Ingress)
-			glog.V(3).Infof("Adding Ingress: %v", ingress.Name)
+			nl.Debugf(lbc.logger, "Adding Ingress: %v", ingress.Name)
 			lbc.AddSyncQueue(obj)
 		},
 		DeleteFunc: func(obj interface{}) {
@@ -29,23 +30,23 @@ func createIngressHandlers(lbc *LoadBalancerController) cache.ResourceEventHandl
 			if !isIng {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				ingress, ok = deletedState.Obj.(*networking.Ingress)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-Ingress object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-Ingress object: %v", deletedState.Obj)
 					return
 				}
 			}
-			glog.V(3).Infof("Removing Ingress: %v", ingress.Name)
+			nl.Debugf(lbc.logger, "Removing Ingress: %v", ingress.Name)
 			lbc.AddSyncQueue(obj)
 		},
 		UpdateFunc: func(old, current interface{}) {
 			c := current.(*networking.Ingress)
 			o := old.(*networking.Ingress)
 			if hasChanges(o, c) {
-				glog.V(3).Infof("Ingress %v changed, syncing", c.Name)
+				nl.Debugf(lbc.logger, "Ingress %v changed, syncing", c.Name)
 				lbc.AddSyncQueue(c)
 			}
 		},
@@ -58,10 +59,10 @@ func createSecretHandlers(lbc *LoadBalancerController) cache.ResourceEventHandle
 		AddFunc: func(obj interface{}) {
 			secret := obj.(*v1.Secret)
 			if !secrets.IsSupportedSecretType(secret.Type) {
-				glog.V(3).Infof("Ignoring Secret %v of unsupported type %v", secret.Name, secret.Type)
+				nl.Debugf(lbc.logger, "Ignoring Secret %v of unsupported type %v", secret.Name, secret.Type)
 				return
 			}
-			glog.V(3).Infof("Adding Secret: %v", secret.Name)
+			nl.Debugf(lbc.logger, "Adding Secret: %v", secret.Name)
 			lbc.AddSyncQueue(obj)
 		},
 		DeleteFunc: func(obj interface{}) {
@@ -69,33 +70,33 @@ func createSecretHandlers(lbc *LoadBalancerController) cache.ResourceEventHandle
 			if !isSecr {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				secret, ok = deletedState.Obj.(*v1.Secret)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-Secret object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-Secret object: %v", deletedState.Obj)
 					return
 				}
 			}
 			if !secrets.IsSupportedSecretType(secret.Type) {
-				glog.V(3).Infof("Ignoring Secret %v of unsupported type %v", secret.Name, secret.Type)
+				nl.Debugf(lbc.logger, "Ignoring Secret %v of unsupported type %v", secret.Name, secret.Type)
 				return
 			}
 
-			glog.V(3).Infof("Removing Secret: %v", secret.Name)
+			nl.Debugf(lbc.logger, "Removing Secret: %v", secret.Name)
 			lbc.AddSyncQueue(obj)
 		},
 		UpdateFunc: func(old, cur interface{}) {
 			// A secret cannot change its type. That's why we only need to check the type of the current secret.
 			curSecret := cur.(*v1.Secret)
 			if !secrets.IsSupportedSecretType(curSecret.Type) {
-				glog.V(3).Infof("Ignoring Secret %v of unsupported type %v", curSecret.Name, curSecret.Type)
+				nl.Debugf(lbc.logger, "Ignoring Secret %v of unsupported type %v", curSecret.Name, curSecret.Type)
 				return
 			}
 
 			if !reflect.DeepEqual(old, cur) {
-				glog.V(3).Infof("Secret %v changed, syncing", cur.(*v1.Secret).Name)
+				nl.Debugf(lbc.logger, "Secret %v changed, syncing", cur.(*v1.Secret).Name)
 				lbc.AddSyncQueue(cur)
 			}
 		},
@@ -106,7 +107,7 @@ func createVirtualServerHandlers(lbc *LoadBalancerController) cache.ResourceEven
 	return cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			vs := obj.(*conf_v1.VirtualServer)
-			glog.V(3).Infof("Adding VirtualServer: %v", vs.Name)
+			nl.Debugf(lbc.logger, "Adding VirtualServer: %v", vs.Name)
 			lbc.AddSyncQueue(vs)
 		},
 		DeleteFunc: func(obj interface{}) {
@@ -114,16 +115,16 @@ func createVirtualServerHandlers(lbc *LoadBalancerController) cache.ResourceEven
 			if !isVs {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				vs, ok = deletedState.Obj.(*conf_v1.VirtualServer)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-VirtualServer object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-VirtualServer object: %v", deletedState.Obj)
 					return
 				}
 			}
-			glog.V(3).Infof("Removing VirtualServer: %v", vs.Name)
+			nl.Debugf(lbc.logger, "Removing VirtualServer: %v", vs.Name)
 			lbc.AddSyncQueue(vs)
 		},
 		UpdateFunc: func(old, cur interface{}) {
@@ -134,13 +135,13 @@ func createVirtualServerHandlers(lbc *LoadBalancerController) cache.ResourceEven
 				var curVsCopy, oldVsCopy conf_v1.VirtualServer
 				err := copier.CopyWithOption(&curVsCopy, curVs, copier.Option{DeepCopy: true})
 				if err != nil {
-					glog.V(3).Infof("Error copying VirtualServer %v: %v for Dynamic Weight Changes", curVs.Name, err)
+					nl.Debugf(lbc.logger, "Error copying VirtualServer %v: %v for Dynamic Weight Changes", curVs.Name, err)
 					return
 				}
 
 				err = copier.CopyWithOption(&oldVsCopy, oldVs, copier.Option{DeepCopy: true})
 				if err != nil {
-					glog.V(3).Infof("Error copying VirtualServer %v: %v for Dynamic Weight Changes", oldVs.Name, err)
+					nl.Debugf(lbc.logger, "Error copying VirtualServer %v: %v for Dynamic Weight Changes", oldVs.Name, err)
 					return
 				}
 
@@ -155,7 +156,7 @@ func createVirtualServerHandlers(lbc *LoadBalancerController) cache.ResourceEven
 			}
 
 			if !reflect.DeepEqual(oldVs.Spec, curVs.Spec) {
-				glog.V(3).Infof("VirtualServer %v changed, syncing", curVs.Name)
+				nl.Debugf(lbc.logger, "VirtualServer %v changed, syncing", curVs.Name)
 				lbc.AddSyncQueue(curVs)
 			}
 		},
@@ -166,7 +167,7 @@ func createVirtualServerRouteHandlers(lbc *LoadBalancerController) cache.Resourc
 	return cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			vsr := obj.(*conf_v1.VirtualServerRoute)
-			glog.V(3).Infof("Adding VirtualServerRoute: %v", vsr.Name)
+			nl.Debugf(lbc.logger, "Adding VirtualServerRoute: %v", vsr.Name)
 			lbc.AddSyncQueue(vsr)
 		},
 		DeleteFunc: func(obj interface{}) {
@@ -174,16 +175,16 @@ func createVirtualServerRouteHandlers(lbc *LoadBalancerController) cache.Resourc
 			if !isVsr {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				vsr, ok = deletedState.Obj.(*conf_v1.VirtualServerRoute)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-VirtualServerRoute object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-VirtualServerRoute object: %v", deletedState.Obj)
 					return
 				}
 			}
-			glog.V(3).Infof("Removing VirtualServerRoute: %v", vsr.Name)
+			nl.Debugf(lbc.logger, "Removing VirtualServerRoute: %v", vsr.Name)
 			lbc.AddSyncQueue(vsr)
 		},
 		UpdateFunc: func(old, cur interface{}) {
@@ -194,13 +195,13 @@ func createVirtualServerRouteHandlers(lbc *LoadBalancerController) cache.Resourc
 				var curVsrCopy, oldVsrCopy conf_v1.VirtualServerRoute
 				err := copier.CopyWithOption(&curVsrCopy, curVsr, copier.Option{DeepCopy: true})
 				if err != nil {
-					glog.V(3).Infof("Error copying VirtualServerRoute %v: %v for Dynamic Weight Changes", curVsr.Name, err)
+					nl.Debugf(lbc.logger, "Error copying VirtualServerRoute %v: %v for Dynamic Weight Changes", curVsr.Name, err)
 					return
 				}
 
 				err = copier.CopyWithOption(&oldVsrCopy, oldVsr, copier.Option{DeepCopy: true})
 				if err != nil {
-					glog.V(3).Infof("Error copying VirtualServerRoute %v: %v for Dynamic Weight Changes", oldVsr.Name, err)
+					nl.Debugf(lbc.logger, "Error copying VirtualServerRoute %v: %v for Dynamic Weight Changes", oldVsr.Name, err)
 					return
 				}
 
@@ -215,7 +216,7 @@ func createVirtualServerRouteHandlers(lbc *LoadBalancerController) cache.Resourc
 			}
 
 			if !reflect.DeepEqual(oldVsr.Spec, curVsr.Spec) {
-				glog.V(3).Infof("VirtualServerRoute %v changed, syncing", curVsr.Name)
+				nl.Debugf(lbc.logger, "VirtualServerRoute %v changed, syncing", curVsr.Name)
 				lbc.AddSyncQueue(curVsr)
 			}
 		},
@@ -223,10 +224,10 @@ func createVirtualServerRouteHandlers(lbc *LoadBalancerController) cache.Resourc
 }
 
 // areResourcesDifferent returns true if the resources are different based on their spec.
-func areResourcesDifferent(oldresource, resource *unstructured.Unstructured) (bool, error) {
+func areResourcesDifferent(l *slog.Logger, oldresource, resource *unstructured.Unstructured) (bool, error) {
 	oldSpec, found, err := unstructured.NestedMap(oldresource.Object, "spec")
 	if !found {
-		glog.V(3).Infof("Warning, oldspec has unexpected format")
+		nl.Debugf(l, "Warning, oldspec has unexpected format")
 	}
 	if err != nil {
 		return false, err
@@ -240,7 +241,7 @@ func areResourcesDifferent(oldresource, resource *unstructured.Unstructured) (bo
 	}
 	eq := reflect.DeepEqual(oldSpec, spec)
 	if eq {
-		glog.V(3).Infof("New spec of %v same as old spec", oldresource.GetName())
+		nl.Debugf(l, "New spec of %v same as old spec", oldresource.GetName())
 	}
 	return !eq, nil
 }
diff --git a/internal/k8s/handlers_test.go b/internal/k8s/handlers_test.go
index c06e27aa3..2861c3360 100644
--- a/internal/k8s/handlers_test.go
+++ b/internal/k8s/handlers_test.go
@@ -2,8 +2,12 @@ package k8s
 
 import (
 	"errors"
+	"io"
+	"log/slog"
 	"testing"
 
+	nic_glog "github.com/nginxinc/kubernetes-ingress/internal/logger/glog"
+	"github.com/nginxinc/kubernetes-ingress/internal/logger/levels"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 )
 
@@ -113,8 +117,9 @@ func TestAreResourcesDifferent(t *testing.T) {
 		},
 	}
 
+	l := slog.New(nic_glog.New(io.Discard, &nic_glog.Options{Level: levels.LevelInfo}))
 	for _, test := range tests {
-		result, err := areResourcesDifferent(test.oldR, test.newR)
+		result, err := areResourcesDifferent(l, test.oldR, test.newR)
 		if result != test.expected {
 			t.Errorf("areResourcesDifferent() returned %v but expected %v for the case of %s", result, test.expected, test.msg)
 		}
diff --git a/internal/k8s/ingress_link.go b/internal/k8s/ingress_link.go
index b380fb17b..feaa77f77 100644
--- a/internal/k8s/ingress_link.go
+++ b/internal/k8s/ingress_link.go
@@ -1,7 +1,7 @@
 package k8s
 
 import (
-	"github.com/golang/glog"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/fields"
@@ -13,7 +13,7 @@ func createIngressLinkHandlers(lbc *LoadBalancerController) cache.ResourceEventH
 	return cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
 			link := obj.(*unstructured.Unstructured)
-			glog.V(3).Infof("Adding IngressLink: %v", link.GetName())
+			nl.Debugf(lbc.logger, "Adding IngressLink: %v", link.GetName())
 			lbc.AddSyncQueue(link)
 		},
 		DeleteFunc: func(obj interface{}) {
@@ -22,29 +22,29 @@ func createIngressLinkHandlers(lbc *LoadBalancerController) cache.ResourceEventH
 			if !isUnstructured {
 				deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
 				if !ok {
-					glog.V(3).Infof("Error received unexpected object: %v", obj)
+					nl.Debugf(lbc.logger, "Error received unexpected object: %v", obj)
 					return
 				}
 				link, ok = deletedState.Obj.(*unstructured.Unstructured)
 				if !ok {
-					glog.V(3).Infof("Error DeletedFinalStateUnknown contained non-Unstructured object: %v", deletedState.Obj)
+					nl.Debugf(lbc.logger, "Error DeletedFinalStateUnknown contained non-Unstructured object: %v", deletedState.Obj)
 					return
 				}
 			}
 
-			glog.V(3).Infof("Removing IngressLink: %v", link.GetName())
+			nl.Debugf(lbc.logger, "Removing IngressLink: %v", link.GetName())
 			lbc.AddSyncQueue(link)
 		},
 		UpdateFunc: func(old, cur interface{}) {
 			oldLink := old.(*unstructured.Unstructured)
 			curLink := cur.(*unstructured.Unstructured)
-			different, err := areResourcesDifferent(oldLink, curLink)
+			different, err := areResourcesDifferent(lbc.logger, oldLink, curLink)
 			if err != nil {
-				glog.V(3).Infof("Error when comparing IngressLinks: %v", err)
+				nl.Debugf(lbc.logger, "Error when comparing IngressLinks: %v", err)
 				lbc.AddSyncQueue(curLink)
 			}
 			if different {
-				glog.V(3).Infof("IngressLink %v changed, syncing", oldLink.GetName())
+				nl.Debugf(lbc.logger, "IngressLink %v changed, syncing", oldLink.GetName())
 				lbc.AddSyncQueue(curLink)
 			}
 		},
@@ -69,7 +69,7 @@ func (lbc *LoadBalancerController) addIngressLinkHandler(handlers cache.Resource
 
 func (lbc *LoadBalancerController) syncIngressLink(task task) {
 	key := task.Key
-	glog.V(2).Infof("Adding, Updating or Deleting IngressLink: %v", key)
+	nl.Debugf(lbc.logger, "Adding, Updating or Deleting IngressLink: %v", key)
 
 	obj, exists, err := lbc.ingressLinkLister.GetByKey(key)
 	if err != nil {
@@ -87,13 +87,13 @@ func (lbc *LoadBalancerController) syncIngressLink(task task) {
 		// spec.virtualServerAddress contains the IP of the BIG-IP device
 		ip, found, err := unstructured.NestedString(link.Object, "spec", "virtualServerAddress")
 		if err != nil {
-			glog.Errorf("Failed to get virtualServerAddress from IngressLink %s: %v", key, err)
+			nl.Errorf(lbc.logger, "Failed to get virtualServerAddress from IngressLink %s: %v", key, err)
 			lbc.statusUpdater.ClearStatusFromIngressLink()
 		} else if !found {
-			glog.Errorf("virtualServerAddress is not found in IngressLink %s", key)
+			nl.Errorf(lbc.logger, "virtualServerAddress is not found in IngressLink %s", key)
 			lbc.statusUpdater.ClearStatusFromIngressLink()
 		} else if ip == "" {
-			glog.Warningf("IngressLink %s has the empty virtualServerAddress field", key)
+			nl.Warnf(lbc.logger, "IngressLink %s has the empty virtualServerAddress field", key)
 			lbc.statusUpdater.ClearStatusFromIngressLink()
 		} else {
 			lbc.statusUpdater.SaveStatusFromIngressLink(ip)
@@ -103,22 +103,22 @@ func (lbc *LoadBalancerController) syncIngressLink(task task) {
 	if lbc.reportStatusEnabled() {
 		ingresses := lbc.configuration.GetResourcesWithFilter(resourceFilter{Ingresses: true})
 
-		glog.V(3).Infof("Updating status for %v Ingresses", len(ingresses))
+		nl.Debugf(lbc.logger, "Updating status for %v Ingresses", len(ingresses))
 
 		err := lbc.statusUpdater.UpdateExternalEndpointsForResources(ingresses)
 		if err != nil {
-			glog.Errorf("Error updating ingress status in syncIngressLink: %v", err)
+			nl.Errorf(lbc.logger, "Error updating ingress status in syncIngressLink: %v", err)
 		}
 	}
 
 	if lbc.areCustomResourcesEnabled && lbc.reportCustomResourceStatusEnabled() {
 		virtualServers := lbc.configuration.GetResourcesWithFilter(resourceFilter{VirtualServers: true})
 
-		glog.V(3).Infof("Updating status for %v VirtualServers", len(virtualServers))
+		nl.Debugf(lbc.logger, "Updating status for %v VirtualServers", len(virtualServers))
 
 		err := lbc.statusUpdater.UpdateExternalEndpointsForResources(virtualServers)
 		if err != nil {
-			glog.V(3).Infof("Error updating VirtualServer/VirtualServerRoute status in syncIngressLink: %v", err)
+			nl.Debugf(lbc.logger, "Error updating VirtualServer/VirtualServerRoute status in syncIngressLink: %v", err)
 		}
 	}
 }
diff --git a/internal/k8s/leader.go b/internal/k8s/leader.go
index 49945311f..6bbe1768b 100644
--- a/internal/k8s/leader.go
+++ b/internal/k8s/leader.go
@@ -6,7 +6,7 @@ import (
 	"os"
 	"time"
 
-	"github.com/golang/glog"
+	nl "github.com/nginxinc/kubernetes-ingress/internal/logger"
 	conf_v1 "github.com/nginxinc/kubernetes-ingress/pkg/apis/configuration/v1"
 	"github.com/nginxinc/kubernetes-ingress/pkg/apis/configuration/validation"
 
@@ -60,7 +60,7 @@ func newLeaderElector(client kubernetes.Interface, callbacks leaderelection.Lead
 func createLeaderHandler(lbc *LoadBalancerController) leaderelection.LeaderCallbacks {
 	return leaderelection.LeaderCallbacks{
 		OnStartedLeading: func(ctx context.Context) {
-			glog.V(3).Info("started leading")
+			nl.Debug(lbc.logger, "started leading")
 			// Closing this channel allows the leader to start the telemetry reporting process
 			if lbc.telemetryChan != nil {
 				close(lbc.telemetryChan)
@@ -68,40 +68,40 @@ func createLeaderHandler(lbc *LoadBalancerController) leaderelection.LeaderCallb
 			if lbc.reportIngressStatus {
 				ingresses := lbc.configuration.GetResourcesWithFilter(resourceFilter{Ingresses: true})
 
-				glog.V(3).Infof("Updating status for %v Ingresses", len(ingresses))
+				nl.Debugf(lbc.logger, "Updating status for %v Ingresses", len(ingresses))
 
 				err := lbc.statusUpdater.UpdateExternalEndpointsForResources(ingresses)
 				if err != nil {
-					glog.V(3).Infof("error updating status when starting leading: %v", err)
+					nl.Debugf(lbc.logger, "error updating status when starting leading: %v", err)
 				}
 			}
 
 			if lbc.areCustomResourcesEnabled {
-				glog.V(3).Info("updating VirtualServer and VirtualServerRoutes status")
+				nl.Debug(lbc.logger, "updating VirtualServer and VirtualServerRoutes status")
 
 				err := lbc.updateVirtualServersStatusFromEvents()
 				if err != nil {
-					glog.V(3).Infof("error updating VirtualServers status when starting leading: %v", err)
+					nl.Debugf(lbc.logger, "error updating VirtualServers status when starting leading: %v", err)
 				}
 
 				err = lbc.updateVirtualServerRoutesStatusFromEvents()
 				if err != nil {
-					glog.V(3).Infof("error updating VirtualServerRoutes status when starting leading: %v", err)
+					nl.Debugf(lbc.logger, "error updating VirtualServerRoutes status when starting leading: %v", err)
 				}
 
 				err = lbc.updatePoliciesStatus()
 				if err != nil {
-					glog.V(3).Infof("error updating Policies status when starting leading: %v", err)
+					nl.Debugf(lbc.logger, "error updating Policies status when starting leading: %v", err)
 				}
 
 				err = lbc.updateTransportServersStatusFromEvents()
 				if err != nil {
-					glog.V(3).Infof("error updating TransportServers status when starting leading: %v", err)
+					nl.Debugf(lbc.logger, "error updating TransportServers status when starting leading: %v", err)
 				}
 			}
 		},
 		OnStoppedLeading: func() {
-			glog.V(3).Info("stopped leading")
+			nl.Debug(lbc.logger, "stopped leading")
 		},
 	}
 }
@@ -111,7 +111,7 @@ func (lbc *LoadBalancerController) addLeaderHandler(leaderHandler leaderelection
 	var err error
 	lbc.leaderElector, err = newLeaderElector(lbc.client, leaderHandler, lbc.controllerNamespace, lbc.leaderElectionLockName)
 	if err != nil {
-		glog.V(3).Infof("Error starting LeaderElection: %v", err)
+		nl.Debugf(lbc.logger, "Error starting LeaderElection: %v", err)
 	}
 }