Repository: gruntwork-io/cloud-nuke
Pull request #608 (2023-10-17 22:49:01)

Centralize logging logic to a single file
<!-- Prepend '[WIP]' to the title if this PR is still a work-in-progress. Remove it when it is ready for review! -->

## Description

This is a preliminary work for https://github.com/gruntwork-io/cloud-nuke/issues/599 ticket. 
Tested running the command locally. 


<!-- Description of the changes introduced by this PR. -->

## TODOs

Read the [Gruntwork contribution guidelines](https://gruntwork.notion.site/Gruntwork-Coding-Methodology-02fdcd6e4b004e818553684760bf691e).

- [ ] Update the docs.
- [ ] Run the relevant tests successfully, including pre-commit checks.
- [ ] Ensure any 3rd party code adheres with our [license policy](https://www.notion.so/gruntwork/Gruntwork-licenses-and-open-source-usage-policy-f7dece1f780341c7b69c1763f22b1378) or delete this line if its not applicable.
- [ ] Include release notes. If this PR is backward incompatible, include a migration guide.
- [ ] Attention Grunts - if this PR adds support for a new resource, ensure the `nuke_sandbox` and `nuke_phxdevops` jobs in `.circleci/config.yml` have been updated with appropriate exclusions (either directly in the job or via the `.circleci/nuke_config.yml` file) to prevent nuking IAM roles, groups, resources, etc that are important for the test accounts.


## Release Notes (draft)

<!-- One-line description of the PR that can be included in the final release notes. -->
Added / Removed / Updated [X].

### Migration Guide

<!-- Important: If you made any backward incompatible changes, then you must write a migration guide! -->




Patch:
diff --git a/README.md b/README.md
index 03af035..8b42fe5 100644
--- a/README.md
+++ b/README.md
@@ -467,6 +467,7 @@ of the file that are supported are listed here.
 | ebs                         | EBSVolume                    | ✅ (Volume Name)                       | ✅ (Creation Time)                   | ✅    |
 | ec2                         | EC2                          | ✅ (Instance Name)                     | ✅ (Launch Time)                     | ✅    |
 | ec2-dedicated-hosts         | EC2DedicatedHosts            | ✅ (EC2 Name Tag)                      | ✅ (Allocation Time)                 | ❌    |
+| ec2-dhcp-option             | EC2DhcpOption                | ❌                                     | ❌                                   | ❌    |
 | ec2-keypairs                | EC2KeyPairs                  | ✅ (Key Pair Name)                     | ✅ (Creation Time)                   | ❌    |
 | ecr                         | ECRRepository                | ✅ (Repository Name)                   | ✅ (Creation Time)                   | ❌    |
 | ecscluster                  | ECSCluster                   | ✅ (Cluster Name)                      | ❌                                   | ❌    |
diff --git a/aws/aws.go b/aws/aws.go
index 488830c..3512a0b 100644
--- a/aws/aws.go
+++ b/aws/aws.go
@@ -117,7 +117,7 @@ func nukeAllResourcesInRegion(account *AwsAccountResources, region string) {
 		length := len((*resources).ResourceIdentifiers())
 
 		// Split api calls into batches
-		logging.Logger.Debugf("Terminating %d resources in batches", length)
+		logging.Debugf("Terminating %d resources in batches", length)
 		batches := util.Split((*resources).ResourceIdentifiers(), (*resources).MaxBatchSize())
 
 		for i := 0; i < len(batches); i++ {
@@ -125,7 +125,7 @@ func nukeAllResourcesInRegion(account *AwsAccountResources, region string) {
 			if err := (*resources).Nuke(batch); err != nil {
 				// TODO: Figure out actual error type
 				if strings.Contains(err.Error(), "RequestLimitExceeded") {
-					logging.Logger.Debug(
+					logging.Debug(
 						"Request limit reached. Waiting 1 minute before making new requests",
 					)
 					time.Sleep(1 * time.Minute)
@@ -139,7 +139,7 @@ func nukeAllResourcesInRegion(account *AwsAccountResources, region string) {
 			}
 
 			if i != len(batches)-1 {
-				logging.Logger.Debug("Sleeping for 10 seconds before processing next batch...")
+				logging.Debug("Sleeping for 10 seconds before processing next batch...")
 				time.Sleep(10 * time.Second)
 			}
 		}
diff --git a/aws/resource_registry.go b/aws/resource_registry.go
index b900e1c..43ebb47 100644
--- a/aws/resource_registry.go
+++ b/aws/resource_registry.go
@@ -67,6 +67,8 @@ func getRegisteredRegionalResources() []AwsResources {
 		&resources.EC2DedicatedHosts{},
 		&resources.EC2KeyPairs{},
 		&resources.EC2VPCs{},
+		// Note: nuking EC2 DHCP options after nuking EC2 VPC because DHCP options could be associated with VPCs.
+		&resources.EC2DhcpOption{},
 		&resources.ECR{},
 		&resources.ECSClusters{},
 		&resources.ECSServices{},
diff --git a/aws/resources/access_analyzer.go b/aws/resources/access_analyzer.go
index 381972f..bb3e86f 100644
--- a/aws/resources/access_analyzer.go
+++ b/aws/resources/access_analyzer.go
@@ -33,7 +33,7 @@ func (analyzer *AccessAnalyzer) getAll(c context.Context, configObj config.Confi
 
 func (analyzer *AccessAnalyzer) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No IAM Access Analyzers to nuke in region %s", analyzer.Region)
+		logging.Debugf("No IAM Access Analyzers to nuke in region %s", analyzer.Region)
 		return nil
 	}
 
@@ -42,12 +42,12 @@ func (analyzer *AccessAnalyzer) nukeAll(names []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(names) > 100 {
-		logging.Logger.Errorf("Nuking too many Access Analyzers at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many Access Analyzers at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyAccessAnalyzersErr{}
 	}
 
 	// There is no bulk delete access analyzer API, so we delete the batch of Access Analyzers concurrently using go routines.
-	logging.Logger.Debugf("Deleting all Access Analyzers in region %s", analyzer.Region)
+	logging.Debugf("Deleting all Access Analyzers in region %s", analyzer.Region)
 
 	wg := new(sync.WaitGroup)
 	wg.Add(len(names))
@@ -63,7 +63,7 @@ func (analyzer *AccessAnalyzer) nukeAll(names []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Access Analyzer",
 			}, map[string]interface{}{
diff --git a/aws/resources/acm.go b/aws/resources/acm.go
index 6be8e26..1f7e936 100644
--- a/aws/resources/acm.go
+++ b/aws/resources/acm.go
@@ -10,7 +10,6 @@ import (
 	"github.com/gruntwork-io/cloud-nuke/telemetry"
 	"github.com/gruntwork-io/go-commons/errors"
 	commonTelemetry "github.com/gruntwork-io/go-commons/telemetry"
-	"github.com/pterm/pterm"
 )
 
 // Returns a list of strings of ACM ARNs
@@ -22,14 +21,14 @@ func (a *ACM) getAll(c context.Context, configObj config.Config) ([]*string, err
 	err := a.Client.ListCertificatesPages(params,
 		func(page *acm.ListCertificatesOutput, lastPage bool) bool {
 			for i := range page.CertificateSummaryList {
-				pterm.Debug.Println(fmt.Sprintf("Found ACM %s with domain name %s",
+				logging.Debug(fmt.Sprintf("Found ACM %s with domain name %s",
 					*page.CertificateSummaryList[i].CertificateArn, *page.CertificateSummaryList[i].DomainName))
 				if a.shouldInclude(page.CertificateSummaryList[i], configObj) {
-					pterm.Debug.Println(fmt.Sprintf(
+					logging.Debug(fmt.Sprintf(
 						"Including ACM %s", *page.CertificateSummaryList[i].CertificateArn))
 					acmArns = append(acmArns, page.CertificateSummaryList[i].CertificateArn)
 				} else {
-					pterm.Debug.Println(fmt.Sprintf(
+					logging.Debug(fmt.Sprintf(
 						"Skipping ACM %s", *page.CertificateSummaryList[i].CertificateArn))
 				}
 			}
@@ -50,7 +49,7 @@ func (a *ACM) shouldInclude(acm *acm.CertificateSummary, configObj config.Config
 	}
 
 	if acm.InUse != nil && *acm.InUse {
-		pterm.Debug.Println(fmt.Sprintf("ACM %s is in use", *acm.CertificateArn))
+		logging.Debug(fmt.Sprintf("ACM %s is in use", *acm.CertificateArn))
 		return false
 	}
 
@@ -58,7 +57,7 @@ func (a *ACM) shouldInclude(acm *acm.CertificateSummary, configObj config.Config
 		Name: acm.DomainName,
 		Time: acm.CreatedAt,
 	})
-	pterm.Debug.Println(fmt.Sprintf("shouldInclude result for ACM: %s w/ domain name: %s, time: %s, and config: %+v",
+	logging.Debug(fmt.Sprintf("shouldInclude result for ACM: %s w/ domain name: %s, time: %s, and config: %+v",
 		*acm.CertificateArn, *acm.DomainName, acm.CreatedAt, configObj.ACM))
 	return shouldInclude
 }
@@ -66,11 +65,11 @@ func (a *ACM) shouldInclude(acm *acm.CertificateSummary, configObj config.Config
 // Deletes all ACMs
 func (a *ACM) nukeAll(arns []*string) error {
 	if len(arns) == 0 {
-		logging.Logger.Debugf("No ACMs to nuke in region %s", a.Region)
+		logging.Debugf("No ACMs to nuke in region %s", a.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all ACMs in region %s", a.Region)
+	logging.Debugf("Deleting all ACMs in region %s", a.Region)
 
 	deletedCount := 0
 	for _, acmArn := range arns {
@@ -80,7 +79,7 @@ func (a *ACM) nukeAll(arns []*string) error {
 
 		_, err := a.Client.DeleteCertificate(params)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ACM",
 			}, map[string]interface{}{
@@ -88,7 +87,7 @@ func (a *ACM) nukeAll(arns []*string) error {
 			})
 		} else {
 			deletedCount++
-			logging.Logger.Debugf("Deleted ACM: %s", *acmArn)
+			logging.Debugf("Deleted ACM: %s", *acmArn)
 		}
 
 		e := report.Entry{
@@ -99,6 +98,6 @@ func (a *ACM) nukeAll(arns []*string) error {
 		report.Record(e)
 	}
 
-	logging.Logger.Debugf("[OK] %d ACM(s) terminated in %s", deletedCount, a.Region)
+	logging.Debugf("[OK] %d ACM(s) terminated in %s", deletedCount, a.Region)
 	return nil
 }
diff --git a/aws/resources/acmpca.go b/aws/resources/acmpca.go
index a67ad11..b9ef7ad 100644
--- a/aws/resources/acmpca.go
+++ b/aws/resources/acmpca.go
@@ -63,11 +63,11 @@ func (ap *ACMPCA) shouldInclude(ca *acmpca.CertificateAuthority, configObj confi
 // nukeAll will delete all ACMPCA, which are given by a list of arns.
 func (ap *ACMPCA) nukeAll(arns []*string) error {
 	if len(arns) == 0 {
-		logging.Logger.Debugf("No ACMPCA to nuke in region %s", ap.Region)
+		logging.Debugf("No ACMPCA to nuke in region %s", ap.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all ACMPCA in region %s", ap.Region)
+	logging.Debugf("Deleting all ACMPCA in region %s", ap.Region)
 	// There is no bulk delete acmpca API, so we delete the batch of ARNs concurrently using go routines.
 	wg := new(sync.WaitGroup)
 	wg.Add(len(arns))
@@ -83,7 +83,7 @@ func (ap *ACMPCA) nukeAll(arns []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ACMPCA",
 			}, map[string]interface{}{
@@ -100,7 +100,7 @@ func (ap *ACMPCA) nukeAll(arns []*string) error {
 func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *string) {
 	defer wg.Done()
 
-	logging.Logger.Debugf("Fetching details of CA to be deleted for ACMPCA %s in region %s", *arn, ap.Region)
+	logging.Debugf("Fetching details of CA to be deleted for ACMPCA %s in region %s", *arn, ap.Region)
 	details, detailsErr := ap.Client.DescribeCertificateAuthority(
 		&acmpca.DescribeCertificateAuthorityInput{CertificateAuthorityArn: arn})
 	if detailsErr != nil {
@@ -124,7 +124,7 @@ func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *strin
 		statusSafe != acmpca.CertificateAuthorityStatusDeleted
 
 	if shouldUpdateStatus {
-		logging.Logger.Debugf("Setting status to 'DISABLED' for ACMPCA %s in region %s", *arn, ap.Region)
+		logging.Debugf("Setting status to 'DISABLED' for ACMPCA %s in region %s", *arn, ap.Region)
 		if _, updateStatusErr := ap.Client.UpdateCertificateAuthority(&acmpca.UpdateCertificateAuthorityInput{
 			CertificateAuthorityArn: arn,
 			Status:                  aws.String(acmpca.CertificateAuthorityStatusDisabled),
@@ -133,7 +133,7 @@ func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *strin
 			return
 		}
 
-		logging.Logger.Debugf("Did set status to 'DISABLED' for ACMPCA: %s in region %s", *arn, ap.Region)
+		logging.Debugf("Did set status to 'DISABLED' for ACMPCA: %s in region %s", *arn, ap.Region)
 	}
 
 	_, deleteErr := ap.Client.DeleteCertificateAuthority(&acmpca.DeleteCertificateAuthorityInput{
@@ -156,6 +156,6 @@ func (ap *ACMPCA) deleteAsync(wg *sync.WaitGroup, errChan chan error, arn *strin
 		errChan <- deleteErr
 		return
 	}
-	logging.Logger.Debugf("Deleted ACMPCA: %s successfully", *arn)
+	logging.Debugf("Deleted ACMPCA: %s successfully", *arn)
 	errChan <- nil
 }
diff --git a/aws/resources/ami.go b/aws/resources/ami.go
index 57cc373..87300ad 100644
--- a/aws/resources/ami.go
+++ b/aws/resources/ami.go
@@ -64,11 +64,11 @@ func (ami *AMIs) getAll(c context.Context, configObj config.Config) ([]*string,
 // Deletes all AMI
 func (ami *AMIs) nukeAll(imageIds []*string) error {
 	if len(imageIds) == 0 {
-		logging.Logger.Debugf("No AMI to nuke in region %s", ami.Region)
+		logging.Debugf("No AMI to nuke in region %s", ami.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all AMI in region %s", ami.Region)
+	logging.Debugf("Deleting all AMI in region %s", ami.Region)
 
 	deletedCount := 0
 	for _, imageID := range imageIds {
@@ -87,7 +87,7 @@ func (ami *AMIs) nukeAll(imageIds []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking AMI",
 			}, map[string]interface{}{
@@ -95,10 +95,10 @@ func (ami *AMIs) nukeAll(imageIds []*string) error {
 			})
 		} else {
 			deletedCount++
-			logging.Logger.Debugf("Deleted AMI: %s", *imageID)
+			logging.Debugf("Deleted AMI: %s", *imageID)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d AMI(s) terminated in %s", deletedCount, ami.Region)
+	logging.Debugf("[OK] %d AMI(s) terminated in %s", deletedCount, ami.Region)
 	return nil
 }
diff --git a/aws/resources/apigateway.go b/aws/resources/apigateway.go
index f45ed93..1b645ff 100644
--- a/aws/resources/apigateway.go
+++ b/aws/resources/apigateway.go
@@ -37,17 +37,17 @@ func (gateway *ApiGateway) getAll(c context.Context, configObj config.Config) ([
 
 func (gateway *ApiGateway) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No API Gateways (v1) to nuke in region %s", gateway.Region)
+		logging.Debugf("No API Gateways (v1) to nuke in region %s", gateway.Region)
 	}
 
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many API Gateways (v1) at once (100): " +
+		logging.Errorf("Nuking too many API Gateways (v1) at once (100): " +
 			"halting to avoid hitting AWS API rate limiting")
 		return TooManyApiGatewayErr{}
 	}
 
 	// There is no bulk delete Api Gateway API, so we delete the batch of gateways concurrently using goroutines
-	logging.Logger.Debugf("Deleting Api Gateways (v1) in region %s", gateway.Region)
+	logging.Debugf("Deleting Api Gateways (v1) in region %s", gateway.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -61,7 +61,7 @@ func (gateway *ApiGateway) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking API Gateway",
@@ -95,11 +95,11 @@ func (gateway *ApiGateway) nukeAsync(
 	report.Record(e)
 
 	if err == nil {
-		logging.Logger.Debugf("["+
+		logging.Debugf("["+
 			"OK] API Gateway (v1) %s deleted in %s", aws.StringValue(apigwID), gateway.Region)
 		return
 	}
 
-	logging.Logger.Debugf(
+	logging.Debugf(
 		"[Failed] Error deleting API Gateway (v1) %s in %s", aws.StringValue(apigwID), gateway.Region)
 }
diff --git a/aws/resources/apigatewayv2.go b/aws/resources/apigatewayv2.go
index 22c2786..420ce59 100644
--- a/aws/resources/apigatewayv2.go
+++ b/aws/resources/apigatewayv2.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"fmt"
 	"github.com/aws/aws-sdk-go/service/apigatewayv2/apigatewayv2iface"
-	"github.com/pterm/pterm"
+	"github.com/gruntwork-io/cloud-nuke/logging"
 	"sync"
 
 	commonTelemetry "github.com/gruntwork-io/go-commons/telemetry"
@@ -39,11 +39,11 @@ func (gw *ApiGatewayV2) getAll(c context.Context, configObj config.Config) ([]*s
 
 func (gw *ApiGatewayV2) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		pterm.Debug.Println(fmt.Sprintf("No API Gateways (v2) to nuke in region %s", gw.Region))
+		logging.Debug(fmt.Sprintf("No API Gateways (v2) to nuke in region %s", gw.Region))
 	}
 
 	if len(identifiers) > 100 {
-		pterm.Debug.Println(fmt.Sprintf(
+		logging.Debug(fmt.Sprintf(
 			"Nuking too many API Gateways (v2) at once (100): halting to avoid hitting AWS API rate limiting"))
 		return TooManyApiGatewayV2Err{}
 	}
@@ -54,7 +54,7 @@ func (gw *ApiGatewayV2) nukeAll(identifiers []*string) error {
 	}
 
 	// There is no bulk delete Api Gateway API, so we delete the batch of gateways concurrently using goroutines
-	pterm.Debug.Println(fmt.Sprintf("Deleting Api Gateways (v2) in region %s", gw.Region))
+	logging.Debug(fmt.Sprintf("Deleting Api Gateways (v2) in region %s", gw.Region))
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -98,9 +98,9 @@ func (gw *ApiGatewayV2) deleteAsync(wg *sync.WaitGroup, errChan chan error, apiI
 	report.Record(e)
 
 	if err == nil {
-		pterm.Debug.Println(fmt.Sprintf("Successfully deleted API Gateway (v2) %s in %s", aws.StringValue(apiId), gw.Region))
+		logging.Debug(fmt.Sprintf("Successfully deleted API Gateway (v2) %s in %s", aws.StringValue(apiId), gw.Region))
 	} else {
-		pterm.Debug.Println(fmt.Sprintf("Failed to delete API Gateway (v2) %s in %s", aws.StringValue(apiId), gw.Region))
+		logging.Debug(fmt.Sprintf("Failed to delete API Gateway (v2) %s in %s", aws.StringValue(apiId), gw.Region))
 	}
 }
 
@@ -114,17 +114,17 @@ func deleteAssociatedApiMappings(
 
 	domainNames, err := client.GetDomainNames(&apigatewayv2.GetDomainNamesInput{})
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to get domain names: %s", err))
+		logging.Debug(fmt.Sprintf("Failed to get domain names: %s", err))
 		return errors.WithStackTrace(err)
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d domain names", len(domainNames.Items)))
+	logging.Debug(fmt.Sprintf("Found %d domain names", len(domainNames.Items)))
 	for _, domainName := range domainNames.Items {
 		apiMappings, err := client.GetApiMappings(&apigatewayv2.GetApiMappingsInput{
 			DomainName: domainName.DomainName,
 		})
 		if err != nil {
-			pterm.Debug.Println(fmt.Sprintf("Failed to get api mappings: %s", err))
+			logging.Debug(fmt.Sprintf("Failed to get api mappings: %s", err))
 			return errors.WithStackTrace(err)
 		}
 
@@ -138,11 +138,11 @@ func deleteAssociatedApiMappings(
 				DomainName:   domainName.DomainName,
 			})
 			if err != nil {
-				pterm.Debug.Println(fmt.Sprintf("Failed to delete api mapping: %s", err))
+				logging.Debug(fmt.Sprintf("Failed to delete api mapping: %s", err))
 				return errors.WithStackTrace(err)
 			}
 
-			pterm.Debug.Println(fmt.Sprintf("Deleted api mapping: %s", *apiMapping.ApiMappingId))
+			logging.Debug(fmt.Sprintf("Deleted api mapping: %s", *apiMapping.ApiMappingId))
 		}
 	}
 
diff --git a/aws/resources/asg.go b/aws/resources/asg.go
index 6727b85..7ca7cc6 100644
--- a/aws/resources/asg.go
+++ b/aws/resources/asg.go
@@ -37,11 +37,11 @@ func (ag *ASGroups) getAll(c context.Context, configObj config.Config) ([]*strin
 // Deletes all Auto Scaling Groups
 func (ag *ASGroups) nukeAll(groupNames []*string) error {
 	if len(groupNames) == 0 {
-		logging.Logger.Debugf("No Auto Scaling Groups to nuke in region %s", ag.Region)
+		logging.Debugf("No Auto Scaling Groups to nuke in region %s", ag.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Auto Scaling Groups in region %s", ag.Region)
+	logging.Debugf("Deleting all Auto Scaling Groups in region %s", ag.Region)
 	var deletedGroupNames []*string
 
 	for _, groupName := range groupNames {
@@ -61,7 +61,7 @@ func (ag *ASGroups) nukeAll(groupNames []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ASG",
 			}, map[string]interface{}{
@@ -69,7 +69,7 @@ func (ag *ASGroups) nukeAll(groupNames []*string) error {
 			})
 		} else {
 			deletedGroupNames = append(deletedGroupNames, groupName)
-			logging.Logger.Debugf("Deleted Auto Scaling Group: %s", *groupName)
+			logging.Debugf("Deleted Auto Scaling Group: %s", *groupName)
 		}
 	}
 
@@ -78,7 +78,7 @@ func (ag *ASGroups) nukeAll(groupNames []*string) error {
 			AutoScalingGroupNames: deletedGroupNames,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ASG",
 			}, map[string]interface{}{
@@ -88,6 +88,6 @@ func (ag *ASGroups) nukeAll(groupNames []*string) error {
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Auto Scaling Group(s) deleted in %s", len(deletedGroupNames), ag.Region)
+	logging.Debugf("[OK] %d Auto Scaling Group(s) deleted in %s", len(deletedGroupNames), ag.Region)
 	return nil
 }
diff --git a/aws/resources/backup_vault.go b/aws/resources/backup_vault.go
index 0541e56..e6ec3d2 100644
--- a/aws/resources/backup_vault.go
+++ b/aws/resources/backup_vault.go
@@ -37,11 +37,11 @@ func (bv *BackupVault) getAll(c context.Context, configObj config.Config) ([]*st
 
 func (bv *BackupVault) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No backup vaults to nuke in region %s", bv.Region)
+		logging.Debugf("No backup vaults to nuke in region %s", bv.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all backup vaults in region %s", bv.Region)
+	logging.Debugf("Deleting all backup vaults in region %s", bv.Region)
 	var deletedNames []*string
 
 	for _, name := range names {
@@ -58,7 +58,7 @@ func (bv *BackupVault) nukeAll(names []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking BackupVault",
 			}, map[string]interface{}{
@@ -66,11 +66,11 @@ func (bv *BackupVault) nukeAll(names []*string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted backup vault: %s", aws.StringValue(name))
+			logging.Debugf("Deleted backup vault: %s", aws.StringValue(name))
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d backup vault deleted in %s", len(deletedNames), bv.Region)
+	logging.Debugf("[OK] %d backup vault deleted in %s", len(deletedNames), bv.Region)
 
 	return nil
 }
diff --git a/aws/resources/cloudtrail.go b/aws/resources/cloudtrail.go
index dbcbf63..595aab7 100644
--- a/aws/resources/cloudtrail.go
+++ b/aws/resources/cloudtrail.go
@@ -38,11 +38,11 @@ func (ct *CloudtrailTrail) getAll(c context.Context, configObj config.Config) ([
 
 func (ct *CloudtrailTrail) nukeAll(arns []*string) error {
 	if len(arns) == 0 {
-		logging.Logger.Debugf("No Cloudtrail Trails to nuke in region %s", ct.Region)
+		logging.Debugf("No Cloudtrail Trails to nuke in region %s", ct.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Cloudtrail Trails in region %s", ct.Region)
+	logging.Debugf("Deleting all Cloudtrail Trails in region %s", ct.Region)
 	var deletedArns []*string
 
 	for _, arn := range arns {
@@ -61,7 +61,7 @@ func (ct *CloudtrailTrail) nukeAll(arns []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Cloudtrail",
 			}, map[string]interface{}{
@@ -69,11 +69,11 @@ func (ct *CloudtrailTrail) nukeAll(arns []*string) error {
 			})
 		} else {
 			deletedArns = append(deletedArns, arn)
-			logging.Logger.Debugf("Deleted Cloudtrail Trail: %s", aws.StringValue(arn))
+			logging.Debugf("Deleted Cloudtrail Trail: %s", aws.StringValue(arn))
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Cloudtrail Trail deleted in %s", len(deletedArns), ct.Region)
+	logging.Debugf("[OK] %d Cloudtrail Trail deleted in %s", len(deletedArns), ct.Region)
 
 	return nil
 }
diff --git a/aws/resources/cloudwatch_alarm.go b/aws/resources/cloudwatch_alarm.go
index 5168cb2..66e1016 100644
--- a/aws/resources/cloudwatch_alarm.go
+++ b/aws/resources/cloudwatch_alarm.go
@@ -46,7 +46,7 @@ func (cw *CloudWatchAlarms) getAll(c context.Context, configObj config.Config) (
 
 func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No CloudWatch Alarms to nuke in region %s", cw.Region)
+		logging.Debugf("No CloudWatch Alarms to nuke in region %s", cw.Region)
 		return nil
 	}
 
@@ -55,11 +55,11 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many CloudWatch Alarms at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many CloudWatch Alarms at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyCloudWatchAlarmsErr{}
 	}
 
-	logging.Logger.Debugf("Deleting CloudWatch Alarms in region %s", cw.Region)
+	logging.Debugf("Deleting CloudWatch Alarms in region %s", cw.Region)
 
 	// If the alarm's type is composite alarm, remove the dependency by removing the rule.
 	alarms, err := cw.Client.DescribeAlarms(&cloudwatch.DescribeAlarmsInput{
@@ -67,7 +67,7 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 		AlarmNames: identifiers,
 	})
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking Cloudwatch Alarm Dependency",
 		}, map[string]interface{}{
@@ -84,7 +84,7 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 			AlarmRule: aws.String("FALSE"),
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Cloudwatch Composite Alarm",
 			}, map[string]interface{}{
@@ -119,7 +119,7 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	report.RecordBatch(e)
 
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking Cloudwatch Alarm",
 		}, map[string]interface{}{
@@ -129,7 +129,7 @@ func (cw *CloudWatchAlarms) nukeAll(identifiers []*string) error {
 	}
 
 	for _, alarmName := range identifiers {
-		logging.Logger.Debugf("[OK] CloudWatch Alarm %s was deleted in %s", aws.StringValue(alarmName), cw.Region)
+		logging.Debugf("[OK] CloudWatch Alarm %s was deleted in %s", aws.StringValue(alarmName), cw.Region)
 	}
 	return nil
 }
diff --git a/aws/resources/cloudwatch_dashboard.go b/aws/resources/cloudwatch_dashboard.go
index b1d276c..f04d733 100644
--- a/aws/resources/cloudwatch_dashboard.go
+++ b/aws/resources/cloudwatch_dashboard.go
@@ -36,7 +36,7 @@ func (cwdb *CloudWatchDashboards) getAll(c context.Context, configObj config.Con
 
 func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No CloudWatch Dashboards to nuke in region %s", cwdb.Region)
+		logging.Debugf("No CloudWatch Dashboards to nuke in region %s", cwdb.Region)
 		return nil
 	}
 
@@ -45,11 +45,11 @@ func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many CloudWatch Dashboards at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many CloudWatch Dashboards at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyCloudWatchDashboardsErr{}
 	}
 
-	logging.Logger.Debugf("Deleting CloudWatch Dashboards in region %s", cwdb.Region)
+	logging.Debugf("Deleting CloudWatch Dashboards in region %s", cwdb.Region)
 	input := cloudwatch.DeleteDashboardsInput{DashboardNames: identifiers}
 	_, err := cwdb.Client.DeleteDashboards(&input)
 
@@ -62,7 +62,7 @@ func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
 	report.RecordBatch(e)
 
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking Cloudwatch Dashboard",
 		}, map[string]interface{}{
@@ -72,7 +72,7 @@ func (cwdb *CloudWatchDashboards) nukeAll(identifiers []*string) error {
 	}
 
 	for _, dashboardName := range identifiers {
-		logging.Logger.Debugf("[OK] CloudWatch Dashboard %s was deleted in %s", aws.StringValue(dashboardName), cwdb.Region)
+		logging.Debugf("[OK] CloudWatch Dashboard %s was deleted in %s", aws.StringValue(dashboardName), cwdb.Region)
 	}
 	return nil
 }
diff --git a/aws/resources/cloudwatch_loggroup.go b/aws/resources/cloudwatch_loggroup.go
index 4944108..fef06ed 100644
--- a/aws/resources/cloudwatch_loggroup.go
+++ b/aws/resources/cloudwatch_loggroup.go
@@ -47,7 +47,7 @@ func (csr *CloudWatchLogGroups) getAll(c context.Context, configObj config.Confi
 
 func (csr *CloudWatchLogGroups) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No CloudWatch Log Groups to nuke in region %s", csr.Region)
+		logging.Debugf("No CloudWatch Log Groups to nuke in region %s", csr.Region)
 		return nil
 	}
 
@@ -56,13 +56,13 @@ func (csr *CloudWatchLogGroups) nukeAll(identifiers []*string) error {
 	// has a chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the
 	// limit here because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many CloudWatch LogGroups at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many CloudWatch LogGroups at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyLogGroupsErr{}
 	}
 
 	// There is no bulk delete CloudWatch Log Group API, so we delete the batch of CloudWatch Log Groups concurrently
 	// using go routines.
-	logging.Logger.Debugf("Deleting CloudWatch Log Groups in region %s", csr.Region)
+	logging.Debugf("Deleting CloudWatch Log Groups in region %s", csr.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -114,9 +114,9 @@ func (csr *CloudWatchLogGroups) deleteAsync(wg *sync.WaitGroup, errChan chan err
 
 	logGroupNameStr := aws.StringValue(logGroupName)
 	if err == nil {
-		logging.Logger.Debugf("[OK] CloudWatch Log Group %s deleted in %s", logGroupNameStr, csr.Region)
+		logging.Debugf("[OK] CloudWatch Log Group %s deleted in %s", logGroupNameStr, csr.Region)
 	} else {
-		logging.Logger.Debugf("[Failed] Error deleting CloudWatch Log Group %s in %s: %s", logGroupNameStr, csr.Region, err)
+		logging.Debugf("[Failed] Error deleting CloudWatch Log Group %s in %s: %s", logGroupNameStr, csr.Region, err)
 	}
 }
 
diff --git a/aws/resources/codedeploy_application.go b/aws/resources/codedeploy_application.go
index 8299e7d..f83388f 100644
--- a/aws/resources/codedeploy_application.go
+++ b/aws/resources/codedeploy_application.go
@@ -84,11 +84,11 @@ func (cda *CodeDeployApplications) batchDescribeAndFilter(identifiers []string,
 
 func (cda *CodeDeployApplications) nukeAll(identifiers []string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No CodeDeploy Applications to nuke in region %s", cda.Region)
+		logging.Debugf("No CodeDeploy Applications to nuke in region %s", cda.Region)
 		return nil
 	}
 
-	logging.Logger.Infof("Deleting CodeDeploy Applications in region %s", cda.Region)
+	logging.Infof("Deleting CodeDeploy Applications in region %s", cda.Region)
 
 	var wg sync.WaitGroup
 	errChan := make(chan error, len(identifiers))
@@ -105,7 +105,7 @@ func (cda *CodeDeployApplications) nukeAll(identifiers []string) error {
 	for err := range errChan {
 		allErrors = multierror.Append(allErrors, err)
 
-		logging.Logger.Errorf("[Failed] Error deleting CodeDeploy Application: %s", err)
+		logging.Errorf("[Failed] Error deleting CodeDeploy Application: %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking CodeDeploy Application",
 		}, map[string]interface{}{
@@ -138,8 +138,8 @@ func (cda *CodeDeployApplications) deleteAsync(wg *sync.WaitGroup, errChan chan<
 	report.Record(e)
 
 	if err == nil {
-		logging.Logger.Debugf("[OK] Deleted CodeDeploy Application: %s", identifier)
+		logging.Debugf("[OK] Deleted CodeDeploy Application: %s", identifier)
 	} else {
-		logging.Logger.Debugf("[Failed] Error deleting CodeDeploy Application %s: %s", identifier, err)
+		logging.Debugf("[Failed] Error deleting CodeDeploy Application %s: %s", identifier, err)
 	}
 }
diff --git a/aws/resources/config_recorder.go b/aws/resources/config_recorder.go
index 28e3b6c..5ae4248 100644
--- a/aws/resources/config_recorder.go
+++ b/aws/resources/config_recorder.go
@@ -35,7 +35,7 @@ func (csr *ConfigServiceRecorders) getAll(c context.Context, configObj config.Co
 
 func (csr *ConfigServiceRecorders) nukeAll(configRecorderNames []string) error {
 	if len(configRecorderNames) == 0 {
-		logging.Logger.Debugf("No Config recorders to nuke in region %s", csr.Region)
+		logging.Debugf("No Config recorders to nuke in region %s", csr.Region)
 		return nil
 	}
 
@@ -57,7 +57,7 @@ func (csr *ConfigServiceRecorders) nukeAll(configRecorderNames []string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Config Recorder",
 			}, map[string]interface{}{
@@ -65,10 +65,10 @@ func (csr *ConfigServiceRecorders) nukeAll(configRecorderNames []string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, aws.String(configRecorderName))
-			logging.Logger.Debugf("Deleted Config Recorder: %s", configRecorderName)
+			logging.Debugf("Deleted Config Recorder: %s", configRecorderName)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Config Recorders deleted in %s", len(deletedNames), csr.Region)
+	logging.Debugf("[OK] %d Config Recorders deleted in %s", len(deletedNames), csr.Region)
 	return nil
 }
diff --git a/aws/resources/config_service.go b/aws/resources/config_service.go
index 30f06eb..43bbff6 100644
--- a/aws/resources/config_service.go
+++ b/aws/resources/config_service.go
@@ -40,13 +40,13 @@ func (csr *ConfigServiceRule) getAll(c context.Context, configObj config.Config)
 
 func (csr *ConfigServiceRule) nukeAll(configRuleNames []string) error {
 	if len(configRuleNames) == 0 {
-		logging.Logger.Debugf("No Config service rules to nuke in region %s", csr.Region)
+		logging.Debugf("No Config service rules to nuke in region %s", csr.Region)
 	}
 
 	var deletedConfigRuleNames []*string
 
 	for _, configRuleName := range configRuleNames {
-		pterm.Debug.Println(fmt.Sprintf("Start deleting config service rule: %s", configRuleName))
+		logging.Debug(fmt.Sprintf("Start deleting config service rule: %s", configRuleName))
 		_, err := csr.Client.DeleteRemediationConfiguration(&configservice.DeleteRemediationConfigurationInput{
 			ConfigRuleName: aws.String(configRuleName),
 		})
@@ -75,14 +75,14 @@ func (csr *ConfigServiceRule) nukeAll(configRuleNames []string) error {
 		}
 
 		deletedConfigRuleNames = append(deletedConfigRuleNames, aws.String(configRuleName))
-		pterm.Debug.Println(fmt.Sprintf("Successfully deleted config service rule: %s", configRuleName))
+		logging.Debug(fmt.Sprintf("Successfully deleted config service rule: %s", configRuleName))
 		report.Record(report.Entry{
 			Identifier:   configRuleName,
 			ResourceType: "Config service rule",
 		})
 	}
 
-	pterm.Debug.Println(
+	logging.Debug(
 		fmt.Sprintf("Completed deleting %d config service rules %s", len(deletedConfigRuleNames), csr.Region))
 	return nil
 }
diff --git a/aws/resources/dynamodb.go b/aws/resources/dynamodb.go
index cd882b6..5ebdd36 100644
--- a/aws/resources/dynamodb.go
+++ b/aws/resources/dynamodb.go
@@ -45,11 +45,11 @@ func (ddb *DynamoDB) getAll(c context.Context, configObj config.Config) ([]*stri
 
 func (ddb *DynamoDB) nukeAll(tables []*string) error {
 	if len(tables) == 0 {
-		logging.Logger.Debugf("No DynamoDB tables to nuke in region %s", ddb.Region)
+		logging.Debugf("No DynamoDB tables to nuke in region %s", ddb.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all DynamoDB tables in region %s", ddb.Region)
+	logging.Debugf("Deleting all DynamoDB tables in region %s", ddb.Region)
 	for _, table := range tables {
 
 		input := &dynamodb.DeleteTableInput{
diff --git a/aws/resources/ebs.go b/aws/resources/ebs.go
index f8cdf2e..d130173 100644
--- a/aws/resources/ebs.go
+++ b/aws/resources/ebs.go
@@ -58,11 +58,11 @@ func shouldIncludeEBSVolume(volume *ec2.Volume, configObj config.Config) bool {
 // Deletes all EBS Volumes
 func (ev *EBSVolumes) nukeAll(volumeIds []*string) error {
 	if len(volumeIds) == 0 {
-		logging.Logger.Debugf("No EBS volumes to nuke in region %s", ev.Region)
+		logging.Debugf("No EBS volumes to nuke in region %s", ev.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all EBS volumes in region %s", ev.Region)
+	logging.Debugf("Deleting all EBS volumes in region %s", ev.Region)
 	var deletedVolumeIDs []*string
 
 	for _, volumeID := range volumeIds {
@@ -88,7 +88,7 @@ func (ev *EBSVolumes) nukeAll(volumeIds []*string) error {
 					"region": ev.Region,
 					"reason": "VolumeInUse",
 				})
-				logging.Logger.Debugf("EBS volume %s can't be deleted, it is still attached to an active resource", *volumeID)
+				logging.Debugf("EBS volume %s can't be deleted, it is still attached to an active resource", *volumeID)
 			} else if awsErr, isAwsErr := err.(awserr.Error); isAwsErr && awsErr.Code() == "InvalidVolume.NotFound" {
 				telemetry.TrackEvent(commonTelemetry.EventContext{
 					EventName: "Error Nuking EBS Volume",
@@ -96,18 +96,18 @@ func (ev *EBSVolumes) nukeAll(volumeIds []*string) error {
 					"region": ev.Region,
 					"reason": "InvalidVolume.NotFound",
 				})
-				logging.Logger.Debugf("EBS volume %s has already been deleted", *volumeID)
+				logging.Debugf("EBS volume %s has already been deleted", *volumeID)
 			} else {
 				telemetry.TrackEvent(commonTelemetry.EventContext{
 					EventName: "Error Nuking EBS Volume",
 				}, map[string]interface{}{
 					"region": ev.Region,
 				})
-				logging.Logger.Debugf("[Failed] %s", err)
+				logging.Debugf("[Failed] %s", err)
 			}
 		} else {
 			deletedVolumeIDs = append(deletedVolumeIDs, volumeID)
-			logging.Logger.Debugf("Deleted EBS Volume: %s", *volumeID)
+			logging.Debugf("Deleted EBS Volume: %s", *volumeID)
 		}
 	}
 
@@ -116,7 +116,7 @@ func (ev *EBSVolumes) nukeAll(volumeIds []*string) error {
 			VolumeIds: deletedVolumeIDs,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking EBS Volume",
 			}, map[string]interface{}{
@@ -126,6 +126,6 @@ func (ev *EBSVolumes) nukeAll(volumeIds []*string) error {
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d EBS volumes(s) terminated in %s", len(deletedVolumeIDs), ev.Region)
+	logging.Debugf("[OK] %d EBS volumes(s) terminated in %s", len(deletedVolumeIDs), ev.Region)
 	return nil
 }
diff --git a/aws/resources/ec2.go b/aws/resources/ec2.go
index 9cd5a60..7a34f60 100644
--- a/aws/resources/ec2.go
+++ b/aws/resources/ec2.go
@@ -91,11 +91,11 @@ func shouldIncludeInstanceId(instance *ec2.Instance, protected bool, configObj c
 // Deletes all non protected EC2 instances
 func (ei *EC2Instances) nukeAll(instanceIds []*string) error {
 	if len(instanceIds) == 0 {
-		logging.Logger.Debugf("No EC2 instances to nuke in region %s", ei.Region)
+		logging.Debugf("No EC2 instances to nuke in region %s", ei.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Terminating all EC2 instances in region %s", ei.Region)
+	logging.Debugf("Terminating all EC2 instances in region %s", ei.Region)
 
 	params := &ec2.TerminateInstancesInput{
 		InstanceIds: instanceIds,
@@ -103,7 +103,7 @@ func (ei *EC2Instances) nukeAll(instanceIds []*string) error {
 
 	_, err := ei.Client.TerminateInstances(params)
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking EC2 Instance",
 		}, map[string]interface{}{
@@ -122,11 +122,11 @@ func (ei *EC2Instances) nukeAll(instanceIds []*string) error {
 	})
 
 	for _, instanceID := range instanceIds {
-		logging.Logger.Debugf("Terminated EC2 Instance: %s", *instanceID)
+		logging.Debugf("Terminated EC2 Instance: %s", *instanceID)
 	}
 
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking EC2 Instance",
 		}, map[string]interface{}{
@@ -135,7 +135,7 @@ func (ei *EC2Instances) nukeAll(instanceIds []*string) error {
 		return errors.WithStackTrace(err)
 	}
 
-	logging.Logger.Debugf("[OK] %d instance(s) terminated in %s", len(instanceIds), ei.Region)
+	logging.Debugf("[OK] %d instance(s) terminated in %s", len(instanceIds), ei.Region)
 	return nil
 }
 
@@ -175,7 +175,7 @@ func GetDefaultVpcId(vpc Vpc) (string, error) {
 	}
 	vpcs, err := vpc.svc.DescribeVpcs(input)
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		return "", errors.WithStackTrace(err)
 	}
 	if len(vpcs.Vpcs) == 1 {
@@ -223,7 +223,7 @@ func (v Vpc) nukeInternetGateway(spinner *pterm.SpinnerPrinter) error {
 	if len(igw.InternetGateways) == 1 {
 		msg := fmt.Sprintf("...detaching Internet Gateway %s", awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId))
 		spinner.UpdateText(msg)
-		logging.Logger.Debug(msg)
+		logging.Debug(msg)
 		_, err := v.svc.DetachInternetGateway(
 			&ec2.DetachInternetGatewayInput{
 				InternetGatewayId: igw.InternetGateways[0].InternetGatewayId,
@@ -236,7 +236,7 @@ func (v Vpc) nukeInternetGateway(spinner *pterm.SpinnerPrinter) error {
 
 		spinnerMsg := fmt.Sprintf("...deleting Internet Gateway %s", awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId))
 		spinner.UpdateText(spinnerMsg)
-		logging.Logger.Debugf(spinnerMsg)
+		logging.Debugf(spinnerMsg)
 		_, err = v.svc.DeleteInternetGateway(
 			&ec2.DeleteInternetGatewayInput{
 				InternetGatewayId: igw.InternetGateways[0].InternetGatewayId,
@@ -247,7 +247,7 @@ func (v Vpc) nukeInternetGateway(spinner *pterm.SpinnerPrinter) error {
 		}
 	} else {
 		spinnerMsg := "...no Internet Gateway found"
-		logging.Logger.Debug(spinnerMsg)
+		logging.Debug(spinnerMsg)
 	}
 
 	return nil
@@ -268,7 +268,7 @@ func (v Vpc) nukeSubnets(spinner *pterm.SpinnerPrinter) error {
 		for _, subnet := range subnets.Subnets {
 			msg := fmt.Sprintf("...deleting subnet %s", awsgo.StringValue(subnet.SubnetId))
 			spinner.UpdateText(msg)
-			logging.Logger.Debug(msg)
+			logging.Debug(msg)
 			_, err := v.svc.DeleteSubnet(
 				&ec2.DeleteSubnetInput{
 					SubnetId: subnet.SubnetId,
@@ -280,7 +280,7 @@ func (v Vpc) nukeSubnets(spinner *pterm.SpinnerPrinter) error {
 		}
 	} else {
 		msg := "...no subnets found"
-		logging.Logger.Debug(msg)
+		logging.Debug(msg)
 	}
 	return nil
 }
@@ -304,7 +304,7 @@ func (v Vpc) nukeRouteTables(spinner *pterm.SpinnerPrinter) error {
 
 		msg := fmt.Sprintf("...deleting route table %s", awsgo.StringValue(routeTable.RouteTableId))
 		spinner.UpdateText(msg)
-		logging.Logger.Debug(msg)
+		logging.Debug(msg)
 		_, err := v.svc.DeleteRouteTable(
 			&ec2.DeleteRouteTableInput{
 				RouteTableId: routeTable.RouteTableId,
@@ -335,7 +335,7 @@ func (v Vpc) nukeNacls(spinner *pterm.SpinnerPrinter) error {
 	for _, networkACL := range networkACLs.NetworkAcls {
 		msg := fmt.Sprintf("...deleting Network ACL %s", awsgo.StringValue(networkACL.NetworkAclId))
 		spinner.UpdateText(msg)
-		logging.Logger.Debug(msg)
+		logging.Debug(msg)
 		_, err := v.svc.DeleteNetworkAcl(
 			&ec2.DeleteNetworkAclInput{
 				NetworkAclId: networkACL.NetworkAclId,
@@ -374,7 +374,7 @@ func (v Vpc) nukeSecurityGroups(spinner *pterm.SpinnerPrinter) error {
 		for _, securityGroupRule := range securityGroupRules.SecurityGroupRules {
 			msg := fmt.Sprintf("...deleting Security Group Rule %s", awsgo.StringValue(securityGroupRule.SecurityGroupRuleId))
 			spinner.UpdateText(msg)
-			logging.Logger.Debug(msg)
+			logging.Debug(msg)
 			if *securityGroupRule.IsEgress {
 				_, err := v.svc.RevokeSecurityGroupEgress(
 					&ec2.RevokeSecurityGroupEgressInput{
@@ -402,7 +402,7 @@ func (v Vpc) nukeSecurityGroups(spinner *pterm.SpinnerPrinter) error {
 	for _, securityGroup := range securityGroups.SecurityGroups {
 		msg := fmt.Sprintf("...deleting Security Group %s", awsgo.StringValue(securityGroup.GroupId))
 		spinner.UpdateText(msg)
-		logging.Logger.Debug(msg)
+		logging.Debug(msg)
 		if *securityGroup.GroupName != "default" {
 			_, err := v.svc.DeleteSecurityGroup(
 				&ec2.DeleteSecurityGroupInput{
@@ -435,13 +435,13 @@ func (v Vpc) nukeEndpoints(spinner *pterm.SpinnerPrinter) error {
 		endpointIds = append(endpointIds, endpoint.VpcEndpointId)
 		msg := fmt.Sprintf("...deleting VPC endpoint %s", awsgo.StringValue(endpoint.VpcEndpointId))
 		spinner.UpdateText(msg)
-		logging.Logger.Debugf(msg)
+		logging.Debugf(msg)
 	}
 
 	if len(endpointIds) == 0 {
 		msg := "...no endpoints found"
 		spinner.UpdateText(msg)
-		logging.Logger.Debug(msg)
+		logging.Debug(msg)
 		return nil
 	}
 
@@ -463,7 +463,7 @@ func (v Vpc) nukeEgressOnlyGateways(spinner *pterm.SpinnerPrinter) error {
 	allEgressGateways := []*string{}
 	msg := "Finding Egress Only Internet Gateways to Nuke"
 	spinner.UpdateText(msg)
-	logging.Logger.Debug(msg)
+	logging.Debug(msg)
 	err := v.svc.DescribeEgressOnlyInternetGatewaysPages(
 		&ec2.DescribeEgressOnlyInternetGatewaysInput{},
 		func(page *ec2.DescribeEgressOnlyInternetGatewaysOutput, lastPage bool) bool {
@@ -483,7 +483,7 @@ func (v Vpc) nukeEgressOnlyGateways(spinner *pterm.SpinnerPrinter) error {
 	}
 	finalMsg := fmt.Sprintf("Found %d Egress Only Internet Gateways to Nuke.", len(allEgressGateways))
 	spinner.UpdateText(finalMsg)
-	logging.Logger.Debug(finalMsg)
+	logging.Debug(finalMsg)
 
 	var allErrs *multierror.Error
 	for _, gateway := range allEgressGateways {
@@ -497,7 +497,7 @@ func (v Vpc) nukeNetworkInterfaces(spinner *pterm.SpinnerPrinter) error {
 	allNetworkInterfaces := []*string{}
 	msg := "Finding Elastic Network Interfaces to Nuke"
 	spinner.UpdateText(msg)
-	logging.Logger.Debug(msg)
+	logging.Debug(msg)
 	vpcIds := []string{v.VpcId}
 	filters := []*ec2.Filter{{Name: awsgo.String("vpc-id"), Values: awsgo.StringSlice(vpcIds)}}
 	err := v.svc.DescribeNetworkInterfacesPages(
@@ -517,7 +517,7 @@ func (v Vpc) nukeNetworkInterfaces(spinner *pterm.SpinnerPrinter) error {
 
 	finalMsg := fmt.Sprintf("Found %d ELastic Network Interfaces to Nuke.", len(allNetworkInterfaces))
 	spinner.UpdateText(finalMsg)
-	logging.Logger.Debug(finalMsg)
+	logging.Debug(finalMsg)
 
 	var allErrs *multierror.Error
 	for _, netInterface := range allNetworkInterfaces {
@@ -562,7 +562,7 @@ func waitForVPCEndpointsToBeDeleted(v Vpc) error {
 		}
 
 		time.Sleep(20 * time.Second)
-		logging.Logger.Debug("Waiting for VPC endpoints to be deleted...")
+		logging.Debug("Waiting for VPC endpoints to be deleted...")
 	}
 
 	return VPCEndpointDeleteTimeoutError{}
@@ -577,7 +577,7 @@ func (e VPCEndpointDeleteTimeoutError) Error() string {
 func (v Vpc) nukeVpc(spinner *pterm.SpinnerPrinter) error {
 	msg := fmt.Sprintf("Deleting VPC %s", v.VpcId)
 	spinner.UpdateText(msg)
-	logging.Logger.Debug(msg)
+	logging.Debug(msg)
 	input := &ec2.DeleteVpcInput{
 		VpcId: awsgo.String(v.VpcId),
 	}
@@ -589,73 +589,73 @@ func (v Vpc) nukeVpc(spinner *pterm.SpinnerPrinter) error {
 }
 
 func (v Vpc) nuke(spinner *pterm.SpinnerPrinter) error {
-	logging.Logger.Debugf("Nuking VPC %s in region %s", v.VpcId, v.Region)
+	logging.Debugf("Nuking VPC %s in region %s", v.VpcId, v.Region)
 	spinner.UpdateText(fmt.Sprintf("Nuking VPC %s in region %s", v.VpcId, v.Region))
 
 	err := v.nukeInternetGateway(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Internet Gateway for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Internet Gateway for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeEgressOnlyGateways(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Egress Only Internet Gateways for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Egress Only Internet Gateways for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeEndpoints(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Endpoints for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Endpoints for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeNetworkInterfaces(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Elastic Network Interfaces for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Elastic Network Interfaces for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeSubnets(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Subnets for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Subnets for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeRouteTables(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Route Tables for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Route Tables for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeNacls(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Network ACLs for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Network ACLs for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeSecurityGroups(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up Security Groups for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up Security Groups for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.dissociateDhcpOptions(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error cleaning up DHCP Options for VPC %s: %s", v.VpcId, err.Error())
+		logging.Debugf("Error cleaning up DHCP Options for VPC %s: %s", v.VpcId, err.Error())
 		return err
 	}
 
 	err = v.nukeVpc(spinner)
 	if err != nil {
-		logging.Logger.Debugf("Error deleting VPC %s: %s ", v.VpcId, err)
+		logging.Debugf("Error deleting VPC %s: %s ", v.VpcId, err)
 		return err
 	}
 	return nil
 }
 
 func NukeVpcs(vpcs []Vpc) error {
-	logging.Logger.Debugf("Deleting the following VPCs:%+v\n", vpcs)
+	logging.Debugf("Deleting the following VPCs:%+v\n", vpcs)
 
 	spinnerMsg := fmt.Sprintf("Nuking the following vpcs: %+v\n", vpcs)
 	// Start a simple spinner to track progress reading all relevant AWS resources
@@ -678,11 +678,11 @@ func NukeVpcs(vpcs []Vpc) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("Skipping to the next default VPC")
+			logging.Debugf("Skipping to the next default VPC")
 			continue
 		}
 	}
-	logging.Logger.Debug("Finished nuking default VPCs in all regions")
+	logging.Debug("Finished nuking default VPCs in all regions")
 	return nil
 }
 
@@ -771,13 +771,13 @@ func (sg DefaultSecurityGroup) getDefaultSecurityGroupIPv6EgressRule() *ec2.Revo
 }
 
 func (sg DefaultSecurityGroup) nuke() error {
-	logging.Logger.Debugf("...revoking default rules from Security Group %s", sg.GroupId)
+	logging.Debugf("...revoking default rules from Security Group %s", sg.GroupId)
 	if sg.GroupName == "default" {
 		ingressRule := sg.getDefaultSecurityGroupIngressRule()
 		_, err := sg.svc.RevokeSecurityGroupIngress(ingressRule)
 		if err != nil {
 			if awsErr, isAwsErr := err.(awserr.Error); isAwsErr && awsErr.Code() == "InvalidPermission.NotFound" {
-				logging.Logger.Debugf("Egress rule not present (ok)")
+				logging.Debugf("Egress rule not present (ok)")
 			} else {
 				return fmt.Errorf("error deleting ingress rule: %s", errors.WithStackTrace(err))
 			}
@@ -787,7 +787,7 @@ func (sg DefaultSecurityGroup) nuke() error {
 		_, err = sg.svc.RevokeSecurityGroupEgress(egressRule)
 		if err != nil {
 			if awsErr, isAwsErr := err.(awserr.Error); isAwsErr && awsErr.Code() == "InvalidPermission.NotFound" {
-				logging.Logger.Debugf("Ingress rule not present (ok)")
+				logging.Debugf("Ingress rule not present (ok)")
 			} else {
 				return fmt.Errorf("error deleting eggress rule: %s", errors.WithStackTrace(err))
 			}
@@ -797,7 +797,7 @@ func (sg DefaultSecurityGroup) nuke() error {
 		_, err = sg.svc.RevokeSecurityGroupEgress(ipv6EgressRule)
 		if err != nil {
 			if awsErr, isAwsErr := err.(awserr.Error); isAwsErr && awsErr.Code() == "InvalidPermission.NotFound" {
-				logging.Logger.Debugf("Ingress rule not present (ok)")
+				logging.Debugf("Ingress rule not present (ok)")
 			} else {
 				return fmt.Errorf("error deleting eggress rule: %s", errors.WithStackTrace(err))
 			}
@@ -820,12 +820,12 @@ func NukeDefaultSecurityGroupRules(sgs []DefaultSecurityGroup) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("Error: %s", err)
-			logging.Logger.Debugf("Skipping to the next default Security Group")
+			logging.Debugf("Error: %s", err)
+			logging.Debugf("Skipping to the next default Security Group")
 			continue
 		}
 	}
-	logging.Logger.Debug("Finished nuking default Security Groups in all regions")
+	logging.Debug("Finished nuking default Security Groups in all regions")
 	return nil
 }
 
diff --git a/aws/resources/ec2_dedicated_host.go b/aws/resources/ec2_dedicated_host.go
index c7f3b80..dd9a0c9 100644
--- a/aws/resources/ec2_dedicated_host.go
+++ b/aws/resources/ec2_dedicated_host.go
@@ -56,7 +56,7 @@ func shouldIncludeHostId(host *ec2.Host, configObj config.Config) bool {
 
 	// If an instance is using the host allocation we cannot release it
 	if len(host.Instances) != 0 {
-		logging.Logger.Debugf("Host %s has instance(s) still associated, unable to nuke.", *host.HostId)
+		logging.Debugf("Host %s has instance(s) still associated, unable to nuke.", *host.HostId)
 		return false
 	}
 
@@ -72,18 +72,18 @@ func shouldIncludeHostId(host *ec2.Host, configObj config.Config) bool {
 
 func (h *EC2DedicatedHosts) nukeAll(hostIds []*string) error {
 	if len(hostIds) == 0 {
-		logging.Logger.Debugf("No EC2 dedicated hosts to nuke in region %s", h.Region)
+		logging.Debugf("No EC2 dedicated hosts to nuke in region %s", h.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Releasing all EC2 dedicated host allocations in region %s", h.Region)
+	logging.Debugf("Releasing all EC2 dedicated host allocations in region %s", h.Region)
 
 	input := &ec2.ReleaseHostsInput{HostIds: hostIds}
 
 	releaseResult, err := h.Client.ReleaseHosts(input)
 
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking EC2 Dedicated Hosts",
 		}, map[string]interface{}{
@@ -94,7 +94,7 @@ func (h *EC2DedicatedHosts) nukeAll(hostIds []*string) error {
 
 	// Report successes and failures from release host request
 	for _, hostSuccess := range releaseResult.Successful {
-		logging.Logger.Debugf("[OK] Dedicated host %s was released in %s", aws.StringValue(hostSuccess), h.Region)
+		logging.Debugf("[OK] Dedicated host %s was released in %s", aws.StringValue(hostSuccess), h.Region)
 		e := report.Entry{
 			Identifier:   aws.StringValue(hostSuccess),
 			ResourceType: "EC2 Dedicated Host",
@@ -108,7 +108,7 @@ func (h *EC2DedicatedHosts) nukeAll(hostIds []*string) error {
 		}, map[string]interface{}{
 			"region": h.Region,
 		})
-		logging.Logger.Debugf("[ERROR] Unable to release dedicated host %s in %s: %s", aws.StringValue(hostFailed.ResourceId), h.Region, aws.StringValue(hostFailed.Error.Message))
+		logging.Debugf("[ERROR] Unable to release dedicated host %s in %s: %s", aws.StringValue(hostFailed.ResourceId), h.Region, aws.StringValue(hostFailed.Error.Message))
 		e := report.Entry{
 			Identifier:   aws.StringValue(hostFailed.ResourceId),
 			ResourceType: "EC2 Dedicated Host",
diff --git a/aws/resources/ec2_dhcp_option.go b/aws/resources/ec2_dhcp_option.go
new file mode 100644
index 0000000..c09ea0a
--- /dev/null
+++ b/aws/resources/ec2_dhcp_option.go
@@ -0,0 +1,44 @@
+package resources
+
+import (
+	"context"
+	"fmt"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/gruntwork-io/cloud-nuke/config"
+	"github.com/gruntwork-io/go-commons/errors"
+	"github.com/pterm/pterm"
+)
+
+func (v *EC2DhcpOption) getAll(c context.Context, configObj config.Config) ([]*string, error) {
+	var dhcpOptionIds []*string
+	err := v.Client.DescribeDhcpOptionsPages(&ec2.DescribeDhcpOptionsInput{}, func(page *ec2.DescribeDhcpOptionsOutput, lastPage bool) bool {
+		for _, dhcpOption := range page.DhcpOptions {
+			// No specific filters to apply at this point, we can think about introducing
+			// filtering with name tag in the future. In the initial version, we just getAll
+			// without filtering.
+			dhcpOptionIds = append(dhcpOptionIds, dhcpOption.DhcpOptionsId)
+		}
+
+		return !lastPage
+	})
+
+	if err != nil {
+		return nil, errors.WithStackTrace(err)
+	}
+
+	return dhcpOptionIds, nil
+}
+
+func (v *EC2DhcpOption) nukeAll(identifiers []*string) error {
+	for _, identifier := range identifiers {
+		_, err := v.Client.DeleteDhcpOptions(&ec2.DeleteDhcpOptionsInput{
+			DhcpOptionsId: identifier,
+		})
+		if err != nil {
+			pterm.Debug.Println(fmt.Sprintf("Failed to delete DHCP option w/ err: %s.", err))
+			return errors.WithStackTrace(err)
+		}
+	}
+
+	return nil
+}
diff --git a/aws/resources/ec2_dhcp_option_types.go b/aws/resources/ec2_dhcp_option_types.go
new file mode 100644
index 0000000..551722d
--- /dev/null
+++ b/aws/resources/ec2_dhcp_option_types.go
@@ -0,0 +1,54 @@
+package resources
+
+import (
+	"context"
+	awsgo "github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/gruntwork-io/cloud-nuke/config"
+	"github.com/gruntwork-io/go-commons/errors"
+)
+
+type EC2DhcpOption struct {
+	Client ec2iface.EC2API
+	Region string
+	VPCIds []string
+}
+
+func (v *EC2DhcpOption) Init(session *session.Session) {
+	v.Client = ec2.New(session)
+}
+
+// ResourceName - the simple name of the aws resource
+func (v *EC2DhcpOption) ResourceName() string {
+	return "ec2_dhcp_option"
+}
+
+// ResourceIdentifiers - The instance ids of the ec2 instances
+func (v *EC2DhcpOption) ResourceIdentifiers() []string {
+	return v.VPCIds
+}
+
+func (v *EC2DhcpOption) MaxBatchSize() int {
+	// Tentative batch size to ensure AWS doesn't throttle
+	return 49
+}
+
+func (v *EC2DhcpOption) GetAndSetIdentifiers(c context.Context, configObj config.Config) ([]string, error) {
+	identifiers, err := v.getAll(c, configObj)
+	if err != nil {
+		return nil, err
+	}
+
+	v.VPCIds = awsgo.StringValueSlice(identifiers)
+	return v.VPCIds, nil
+}
+
+func (v *EC2DhcpOption) Nuke(identifiers []string) error {
+	if err := v.nukeAll(awsgo.StringSlice(identifiers)); err != nil {
+		return errors.WithStackTrace(err)
+	}
+
+	return nil
+}
diff --git a/aws/resources/ec2_key_pair.go b/aws/resources/ec2_key_pair.go
index 0684d8f..4737adb 100644
--- a/aws/resources/ec2_key_pair.go
+++ b/aws/resources/ec2_key_pair.go
@@ -48,11 +48,11 @@ func (k *EC2KeyPairs) deleteKeyPair(keyPairId *string) error {
 // nukeAllEc2KeyPairs attempts to delete given ec2 key pair IDs.
 func (k *EC2KeyPairs) nukeAll(keypairIds []*string) error {
 	if len(keypairIds) == 0 {
-		logging.Logger.Infof("No EC2 key pairs to nuke in region %s", k.Region)
+		logging.Infof("No EC2 key pairs to nuke in region %s", k.Region)
 		return nil
 	}
 
-	logging.Logger.Infof("Terminating all EC2 key pairs in region %s", k.Region)
+	logging.Infof("Terminating all EC2 key pairs in region %s", k.Region)
 
 	deletedKeyPairs := 0
 	var multiErr *multierror.Error
@@ -63,14 +63,14 @@ func (k *EC2KeyPairs) nukeAll(keypairIds []*string) error {
 			}, map[string]interface{}{
 				"region": k.Region,
 			})
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			multiErr = multierror.Append(multiErr, err)
 		} else {
 			deletedKeyPairs++
-			logging.Logger.Infof("Deleted EC2 KeyPair: %s", *keypair)
+			logging.Infof("Deleted EC2 KeyPair: %s", *keypair)
 		}
 	}
 
-	logging.Logger.Infof("[OK] %d EC2 KeyPair(s) terminated", deletedKeyPairs)
+	logging.Infof("[OK] %d EC2 KeyPair(s) terminated", deletedKeyPairs)
 	return multiErr.ErrorOrNil()
 }
diff --git a/aws/resources/ec2_vpc.go b/aws/resources/ec2_vpc.go
index 93b50ed..d2e26a6 100644
--- a/aws/resources/ec2_vpc.go
+++ b/aws/resources/ec2_vpc.go
@@ -75,7 +75,7 @@ func (v *EC2VPCs) getAll(c context.Context, configObj config.Config) ([]*string,
 	for _, vpc := range result.Vpcs {
 		firstSeenTime, err := v.getFirstSeenTag(*vpc)
 		if err != nil {
-			logging.Logger.Error("Unable to retrieve tags")
+			logging.Error("Unable to retrieve tags")
 			return nil, errors.WithStackTrace(err)
 		}
 
@@ -100,11 +100,11 @@ func (v *EC2VPCs) getAll(c context.Context, configObj config.Config) ([]*string,
 
 func (v *EC2VPCs) nukeAll(vpcIds []string) error {
 	if len(vpcIds) == 0 {
-		pterm.Debug.Println("No VPCs to nuke")
+		logging.Debug("No VPCs to nuke")
 		return nil
 	}
 
-	pterm.Debug.Println("Deleting all VPCs")
+	logging.Debug("Deleting all VPCs")
 
 	deletedVPCs := 0
 	multiErr := new(multierror.Error)
@@ -132,7 +132,7 @@ func (v *EC2VPCs) nukeAll(vpcIds []string) error {
 			multierror.Append(multiErr, err)
 		} else {
 			deletedVPCs++
-			pterm.Debug.Println(fmt.Sprintf("Deleted VPC: %s", id))
+			logging.Debug(fmt.Sprintf("Deleted VPC: %s", id))
 		}
 	}
 
@@ -141,16 +141,16 @@ func (v *EC2VPCs) nukeAll(vpcIds []string) error {
 
 func nuke(client ec2iface.EC2API, vpcID string) error {
 	// Note: order is quite important, otherwise you will encounter dependency violation errors.
-	pterm.Debug.Println(fmt.Sprintf("Start nuking VPC %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking VPC %s", vpcID))
 	err := nukeDhcpOptions(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up DHCP Options for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up DHCP Options for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
 	err = nukeRouteTables(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up Route Tables for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up Route Tables for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
@@ -162,7 +162,7 @@ func nuke(client ec2iface.EC2API, vpcID string) error {
 
 	err = nukeNatGateway(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up NAT Gateways for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up NAT Gateways for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
@@ -174,31 +174,31 @@ func nuke(client ec2iface.EC2API, vpcID string) error {
 
 	err = nukeInternetGateway(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up Internet Gateway for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up Internet Gateway for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
 	err = nukeNacls(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up Network ACLs for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up Network ACLs for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
 	err = nukeSubnets(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up Subnets for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up Subnets for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
 	err = nukeEndpoints(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up Endpoints for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up Endpoints for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
 	err = nukeSecurityGroups(client, vpcID)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Error cleaning up Security Groups for VPC %s: %s", vpcID, err.Error()))
+		logging.Debug(fmt.Sprintf("Error cleaning up Security Groups for VPC %s: %s", vpcID, err.Error()))
 		return err
 	}
 
@@ -208,13 +208,13 @@ func nuke(client ec2iface.EC2API, vpcID string) error {
 		return err
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Successfully nuked VPC %s", vpcID))
-	pterm.Debug.Println()
+	logging.Debug(fmt.Sprintf("Successfully nuked VPC %s", vpcID))
+	logging.Debug("")
 	return nil
 }
 
 func nukeInternetGateway(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking Internet Gateway for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking Internet Gateway for vpc: %s", vpcID))
 	input := &ec2.DescribeInternetGatewaysInput{
 		Filters: []*ec2.Filter{
 			{
@@ -225,16 +225,16 @@ func nukeInternetGateway(client ec2iface.EC2API, vpcID string) error {
 	}
 	igw, err := client.DescribeInternetGateways(input)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to describe internet gateways for vpc: %s", vpcID))
+		logging.Debug(fmt.Sprintf("Failed to describe internet gateways for vpc: %s", vpcID))
 		return errors.WithStackTrace(err)
 	}
 
 	if len(igw.InternetGateways) < 1 {
-		pterm.Debug.Println(fmt.Sprintf("No Internet Gateway to delete."))
+		logging.Debug(fmt.Sprintf("No Internet Gateway to delete."))
 		return nil
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Detaching Internet Gateway %s",
+	logging.Debug(fmt.Sprintf("Detaching Internet Gateway %s",
 		awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId)))
 	_, err = client.DetachInternetGateway(
 		&ec2.DetachInternetGatewayInput{
@@ -243,14 +243,14 @@ func nukeInternetGateway(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to detach internet gateway %s",
+		logging.Debug(fmt.Sprintf("Failed to detach internet gateway %s",
 			awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId)))
 		return errors.WithStackTrace(err)
 	}
-	pterm.Debug.Println(fmt.Sprintf("Successfully detached internet gateway %s",
+	logging.Debug(fmt.Sprintf("Successfully detached internet gateway %s",
 		awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId)))
 
-	pterm.Debug.Println(fmt.Sprintf("Deleting internet gateway %s",
+	logging.Debug(fmt.Sprintf("Deleting internet gateway %s",
 		awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId)))
 	_, err = client.DeleteInternetGateway(
 		&ec2.DeleteInternetGatewayInput{
@@ -258,11 +258,11 @@ func nukeInternetGateway(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to delete internet gateway %s",
+		logging.Debug(fmt.Sprintf("Failed to delete internet gateway %s",
 			awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId)))
 		return errors.WithStackTrace(err)
 	}
-	pterm.Debug.Println(fmt.Sprintf("Successfully deleted internet gateway %s",
+	logging.Debug(fmt.Sprintf("Successfully deleted internet gateway %s",
 		awsgo.StringValue(igw.InternetGateways[0].InternetGatewayId)))
 
 	return nil
@@ -270,7 +270,7 @@ func nukeInternetGateway(client ec2iface.EC2API, vpcID string) error {
 
 func nukeEgressOnlyGateways(client ec2iface.EC2API, vpcID string) error {
 	var allEgressGateways []*string
-	pterm.Debug.Println(fmt.Sprintf("Start nuking Egress Only Internet Gateways for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking Egress Only Internet Gateways for vpc: %s", vpcID))
 	err := client.DescribeEgressOnlyInternetGatewaysPages(
 		&ec2.DescribeEgressOnlyInternetGatewaysInput{},
 		func(page *ec2.DescribeEgressOnlyInternetGatewaysOutput, lastPage bool) bool {
@@ -286,28 +286,28 @@ func nukeEgressOnlyGateways(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to describe Egress Only Internet Gateways for vpc: %s", vpcID))
+		logging.Debug(fmt.Sprintf("Failed to describe Egress Only Internet Gateways for vpc: %s", vpcID))
 		return err
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d Egress Only Internet Gateways to nuke.", len(allEgressGateways)))
+	logging.Debug(fmt.Sprintf("Found %d Egress Only Internet Gateways to nuke.", len(allEgressGateways)))
 	var allErrs *multierror.Error
 	for _, gateway := range allEgressGateways {
 		_, err := client.DeleteEgressOnlyInternetGateway(
 			&ec2.DeleteEgressOnlyInternetGatewayInput{EgressOnlyInternetGatewayId: gateway})
 		if err != nil {
-			pterm.Debug.Println(fmt.Sprintf("Failed to delete Egress Only Internet Gateway %s", *gateway))
+			logging.Debug(fmt.Sprintf("Failed to delete Egress Only Internet Gateway %s", *gateway))
 			allErrs = multierror.Append(allErrs, errors.WithStackTrace(err))
 		}
 
-		pterm.Debug.Println(fmt.Sprintf("Successfully deleted Egress Only Internet Gateway %s", *gateway))
+		logging.Debug(fmt.Sprintf("Successfully deleted Egress Only Internet Gateway %s", *gateway))
 	}
 
 	return nil
 }
 
 func nukeEndpoints(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking VPC endpoints for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking VPC endpoints for vpc: %s", vpcID))
 	endpoints, _ := client.DescribeVpcEndpoints(
 		&ec2.DescribeVpcEndpointsInput{
 			Filters: []*ec2.Filter{
@@ -319,12 +319,12 @@ func nukeEndpoints(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d VPC endpoint.", len(endpoints.VpcEndpoints)))
+	logging.Debug(fmt.Sprintf("Found %d VPC endpoint.", len(endpoints.VpcEndpoints)))
 	var endpointIds []*string
 	for _, endpoint := range endpoints.VpcEndpoints {
 		// Note: sometime the state is all lower cased, sometime it is not.
 		if strings.ToLower(*endpoint.State) != strings.ToLower(ec2.StateAvailable) {
-			pterm.Debug.Println(fmt.Sprintf("Skipping VPC endpoint %s as it is not in available state: %s",
+			logging.Debug(fmt.Sprintf("Skipping VPC endpoint %s as it is not in available state: %s",
 				awsgo.StringValue(endpoint.VpcEndpointId), awsgo.StringValue(endpoint.State)))
 			continue
 		}
@@ -333,7 +333,7 @@ func nukeEndpoints(client ec2iface.EC2API, vpcID string) error {
 	}
 
 	if len(endpointIds) == 0 {
-		pterm.Debug.Println(fmt.Sprintf("No VPC endpoint to nuke."))
+		logging.Debug(fmt.Sprintf("No VPC endpoint to nuke."))
 		return nil
 	}
 
@@ -341,7 +341,7 @@ func nukeEndpoints(client ec2iface.EC2API, vpcID string) error {
 		VpcEndpointIds: endpointIds,
 	})
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to delete VPC endpoints: %s", err.Error()))
+		logging.Debug(fmt.Sprintf("Failed to delete VPC endpoints: %s", err.Error()))
 		return errors.WithStackTrace(err)
 	}
 
@@ -349,7 +349,7 @@ func nukeEndpoints(client ec2iface.EC2API, vpcID string) error {
 		return errors.WithStackTrace(err)
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Successfully deleted VPC endpoints"))
+	logging.Debug(fmt.Sprintf("Successfully deleted VPC endpoints"))
 	return nil
 }
 
@@ -378,14 +378,14 @@ func waitForVPCEndpointToBeDeleted(client ec2iface.EC2API, vpcID string) error {
 		}
 
 		time.Sleep(20 * time.Second)
-		pterm.Debug.Println(fmt.Sprintf("Waiting for VPC endpoints to be deleted..."))
+		logging.Debug(fmt.Sprintf("Waiting for VPC endpoints to be deleted..."))
 	}
 
 	return nil
 }
 
 func nukeNetworkInterfaces(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking network interfaces for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking network interfaces for vpc: %s", vpcID))
 
 	var allNetworkInterfaces []*ec2.NetworkInterface
 	vpcIds := []string{vpcID}
@@ -402,14 +402,14 @@ func nukeNetworkInterfaces(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to describe network interfaces for vpc: %s", vpcID))
+		logging.Debug(fmt.Sprintf("Failed to describe network interfaces for vpc: %s", vpcID))
 		return err
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d Elastic Network Interfaces to Nuke.", len(allNetworkInterfaces)))
+	logging.Debug(fmt.Sprintf("Found %d Elastic Network Interfaces to Nuke.", len(allNetworkInterfaces)))
 	for _, netInterface := range allNetworkInterfaces {
 		if strings.ToLower(*netInterface.Status) == strings.ToLower(ec2.NetworkInterfaceStatusInUse) {
-			pterm.Debug.Println(fmt.Sprintf("Skipping network interface %s as it is in use",
+			logging.Debug(fmt.Sprintf("Skipping network interface %s as it is in use",
 				*netInterface.NetworkInterfaceId))
 			continue
 		}
@@ -418,18 +418,18 @@ func nukeNetworkInterfaces(client ec2iface.EC2API, vpcID string) error {
 			NetworkInterfaceId: netInterface.NetworkInterfaceId,
 		})
 		if err != nil {
-			pterm.Debug.Println(fmt.Sprintf("Failed to delete network interface: %s", *netInterface))
+			logging.Debug(fmt.Sprintf("Failed to delete network interface: %s", *netInterface))
 			return errors.WithStackTrace(err)
 		}
 
-		pterm.Debug.Println(fmt.Sprintf("Successfully deleted network interface: %s", *netInterface.NetworkInterfaceId))
+		logging.Debug(fmt.Sprintf("Successfully deleted network interface: %s", *netInterface.NetworkInterfaceId))
 	}
 
 	return nil
 }
 
 func nukeSubnets(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking subnets for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking subnets for vpc: %s", vpcID))
 	subnets, _ := client.DescribeSubnets(
 		&ec2.DescribeSubnetsInput{
 			Filters: []*ec2.Filter{
@@ -441,7 +441,7 @@ func nukeSubnets(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d subnets to delete ", len(subnets.Subnets)))
+	logging.Debug(fmt.Sprintf("Found %d subnets to delete ", len(subnets.Subnets)))
 	if len(subnets.Subnets) > 0 {
 		for _, subnet := range subnets.Subnets {
 			_, err := client.DeleteSubnet(
@@ -451,16 +451,16 @@ func nukeSubnets(client ec2iface.EC2API, vpcID string) error {
 			)
 
 			if err != nil {
-				pterm.Debug.Println(fmt.Sprintf("Failed to delete subnet %s", awsgo.StringValue(subnet.SubnetId)))
+				logging.Debug(fmt.Sprintf("Failed to delete subnet %s", awsgo.StringValue(subnet.SubnetId)))
 				return errors.WithStackTrace(err)
 			}
-			pterm.Debug.Println(fmt.Sprintf("Successfully deleted subnet %s", awsgo.StringValue(subnet.SubnetId)))
+			logging.Debug(fmt.Sprintf("Successfully deleted subnet %s", awsgo.StringValue(subnet.SubnetId)))
 		}
 
 		return nil
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("No subnets found"))
+	logging.Debug(fmt.Sprintf("No subnets found"))
 	return nil
 }
 
@@ -474,14 +474,14 @@ func nukeNatGateway(client ec2iface.EC2API, vpcID string) error {
 		},
 	})
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to describe NAT gateways for vpc: %s", vpcID))
+		logging.Debug(fmt.Sprintf("Failed to describe NAT gateways for vpc: %s", vpcID))
 		return errors.WithStackTrace(err)
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d NAT gateways to delete", len(gateways.NatGateways)))
+	logging.Debug(fmt.Sprintf("Found %d NAT gateways to delete", len(gateways.NatGateways)))
 	for _, gateway := range gateways.NatGateways {
 		if *gateway.State != ec2.NatGatewayStateAvailable {
-			pterm.Debug.Println(fmt.Sprintf("Skipping NAT gateway %s as it is not in available state: %s",
+			logging.Debug(fmt.Sprintf("Skipping NAT gateway %s as it is not in available state: %s",
 				awsgo.StringValue(gateway.NatGatewayId), awsgo.StringValue(gateway.State)))
 			continue
 		}
@@ -490,11 +490,11 @@ func nukeNatGateway(client ec2iface.EC2API, vpcID string) error {
 			NatGatewayId: gateway.NatGatewayId,
 		})
 		if err != nil {
-			pterm.Debug.Println(
+			logging.Debug(
 				fmt.Sprintf("Failed to delete NAT gateway %s", awsgo.StringValue(gateway.NatGatewayId)))
 			return errors.WithStackTrace(err)
 		}
-		pterm.Debug.Println(
+		logging.Debug(
 			fmt.Sprintf("Successfully deleted NAT gateway %s", awsgo.StringValue(gateway.NatGatewayId)))
 	}
 
@@ -502,7 +502,7 @@ func nukeNatGateway(client ec2iface.EC2API, vpcID string) error {
 }
 
 func nukeRouteTables(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking route tables for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking route tables for vpc: %s", vpcID))
 	routeTables, err := client.DescribeRouteTables(
 		&ec2.DescribeRouteTablesInput{
 			Filters: []*ec2.Filter{
@@ -514,30 +514,30 @@ func nukeRouteTables(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to describe route tables for vpc: %s", vpcID))
+		logging.Debug(fmt.Sprintf("Failed to describe route tables for vpc: %s", vpcID))
 		return errors.WithStackTrace(err)
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d route tables.", len(routeTables.RouteTables)))
+	logging.Debug(fmt.Sprintf("Found %d route tables.", len(routeTables.RouteTables)))
 	for _, routeTable := range routeTables.RouteTables {
 		// Skip main route table
 		if len(routeTable.Associations) > 0 && *routeTable.Associations[0].Main {
-			pterm.Debug.Println(fmt.Sprintf("Skipping main route table: %s",
+			logging.Debug(fmt.Sprintf("Skipping main route table: %s",
 				awsgo.StringValue(routeTable.RouteTableId)))
 			continue
 		}
 
-		pterm.Debug.Println(fmt.Sprintf("Start nuking route table: %s", awsgo.StringValue(routeTable.RouteTableId)))
+		logging.Debug(fmt.Sprintf("Start nuking route table: %s", awsgo.StringValue(routeTable.RouteTableId)))
 		for _, association := range routeTable.Associations {
 			_, err := client.DisassociateRouteTable(&ec2.DisassociateRouteTableInput{
 				AssociationId: association.RouteTableAssociationId,
 			})
 			if err != nil {
-				pterm.Debug.Println(fmt.Sprintf("Failed to disassociate route table: %s",
+				logging.Debug(fmt.Sprintf("Failed to disassociate route table: %s",
 					awsgo.StringValue(association.RouteTableAssociationId)))
 				return errors.WithStackTrace(err)
 			}
-			pterm.Debug.Println(fmt.Sprintf("Successfully disassociated route table: %s",
+			logging.Debug(fmt.Sprintf("Successfully disassociated route table: %s",
 				awsgo.StringValue(association.RouteTableAssociationId)))
 		}
 
@@ -547,10 +547,10 @@ func nukeRouteTables(client ec2iface.EC2API, vpcID string) error {
 			},
 		)
 		if err != nil {
-			pterm.Debug.Println(fmt.Sprintf("Failed to delete route table: %s", awsgo.StringValue(routeTable.RouteTableId)))
+			logging.Debug(fmt.Sprintf("Failed to delete route table: %s", awsgo.StringValue(routeTable.RouteTableId)))
 			return errors.WithStackTrace(err)
 		}
-		pterm.Debug.Println(fmt.Sprintf("Successfully deleted route table: %s", awsgo.StringValue(routeTable.RouteTableId)))
+		logging.Debug(fmt.Sprintf("Successfully deleted route table: %s", awsgo.StringValue(routeTable.RouteTableId)))
 	}
 
 	return nil
@@ -559,7 +559,7 @@ func nukeRouteTables(client ec2iface.EC2API, vpcID string) error {
 // nukeNacls nukes all network ACLs in a VPC except the default one. It replaces all subnet associations with
 // the default in order to prevent dependency violations.
 func nukeNacls(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking network ACLs for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking network ACLs for vpc: %s", vpcID))
 	networkACLs, _ := client.DescribeNetworkAcls(
 		&ec2.DescribeNetworkAclsInput{
 			Filters: []*ec2.Filter{
@@ -581,32 +581,32 @@ func nukeNacls(client ec2iface.EC2API, vpcID string) error {
 	}
 
 	if defaultNetworkAclID == nil {
-		pterm.Debug.Println(fmt.Sprintf("No default network ACL found"))
+		logging.Debug(fmt.Sprintf("No default network ACL found"))
 		return cerrors.New("No default network ACL found in vpc: " + vpcID)
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Found default network ACL: %s", *defaultNetworkAclID))
-	pterm.Debug.Println(fmt.Sprintf("Found %d network ACLs to delete", len(networkACLs.NetworkAcls)-1))
+	logging.Debug(fmt.Sprintf("Found default network ACL: %s", *defaultNetworkAclID))
+	logging.Debug(fmt.Sprintf("Found %d network ACLs to delete", len(networkACLs.NetworkAcls)-1))
 	for _, networkACL := range networkACLs.NetworkAcls {
 		if *networkACL.IsDefault {
 			continue
 		}
 
-		pterm.Debug.Println(fmt.Sprintf(
+		logging.Debug(fmt.Sprintf(
 			"Start nuking network ACL: %s", awsgo.StringValue(networkACL.NetworkAclId)))
 		for _, association := range networkACL.Associations {
-			pterm.Debug.Println(fmt.Sprintf(
+			logging.Debug(fmt.Sprintf(
 				"Found %d network ACL associations to replace", len(networkACL.Associations)))
 			_, err := client.ReplaceNetworkAclAssociation(&ec2.ReplaceNetworkAclAssociationInput{
 				AssociationId: association.NetworkAclAssociationId,
 				NetworkAclId:  defaultNetworkAclID,
 			})
 			if err != nil {
-				pterm.Debug.Println(fmt.Sprintf("Failed to replace network ACL association: %s to default",
+				logging.Debug(fmt.Sprintf("Failed to replace network ACL association: %s to default",
 					awsgo.StringValue(association.NetworkAclAssociationId)))
 				return errors.WithStackTrace(err)
 			}
-			pterm.Debug.Println(fmt.Sprintf("Successfully replaced network ACL association: %s to default",
+			logging.Debug(fmt.Sprintf("Successfully replaced network ACL association: %s to default",
 				awsgo.StringValue(association.NetworkAclAssociationId)))
 		}
 
@@ -616,11 +616,11 @@ func nukeNacls(client ec2iface.EC2API, vpcID string) error {
 			},
 		)
 		if err != nil {
-			pterm.Debug.Println(fmt.Sprintf(
+			logging.Debug(fmt.Sprintf(
 				"Failed to delete network ACL: %s", awsgo.StringValue(networkACL.NetworkAclId)))
 			return errors.WithStackTrace(err)
 		}
-		pterm.Debug.Println(fmt.Sprintf(
+		logging.Debug(fmt.Sprintf(
 			"Successfully deleted network ACL: %s", awsgo.StringValue(networkACL.NetworkAclId)))
 	}
 
@@ -628,7 +628,7 @@ func nukeNacls(client ec2iface.EC2API, vpcID string) error {
 }
 
 func nukeSecurityGroups(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Start nuking security groups for vpc: %s", vpcID))
+	logging.Debug(fmt.Sprintf("Start nuking security groups for vpc: %s", vpcID))
 	securityGroups, _ := client.DescribeSecurityGroups(
 		&ec2.DescribeSecurityGroupsInput{
 			Filters: []*ec2.Filter{
@@ -640,7 +640,7 @@ func nukeSecurityGroups(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 
-	pterm.Debug.Println(fmt.Sprintf("Found %d security groups to delete", len(securityGroups.SecurityGroups)))
+	logging.Debug(fmt.Sprintf("Found %d security groups to delete", len(securityGroups.SecurityGroups)))
 	for _, securityGroup := range securityGroups.SecurityGroups {
 		securityGroupRules, _ := client.DescribeSecurityGroupRules(
 			&ec2.DescribeSecurityGroupRulesInput{
@@ -653,10 +653,10 @@ func nukeSecurityGroups(client ec2iface.EC2API, vpcID string) error {
 			},
 		)
 
-		pterm.Debug.Println(fmt.Sprintf("Found %d security rules to delete for security group: %s",
+		logging.Debug(fmt.Sprintf("Found %d security rules to delete for security group: %s",
 			len(securityGroupRules.SecurityGroupRules), awsgo.StringValue(securityGroup.GroupId)))
 		for _, securityGroupRule := range securityGroupRules.SecurityGroupRules {
-			pterm.Debug.Println(fmt.Sprintf("Deleting Security Group Rule %s", awsgo.StringValue(securityGroupRule.SecurityGroupRuleId)))
+			logging.Debug(fmt.Sprintf("Deleting Security Group Rule %s", awsgo.StringValue(securityGroupRule.SecurityGroupRuleId)))
 			if *securityGroupRule.IsEgress {
 				_, err := client.RevokeSecurityGroupEgress(
 					&ec2.RevokeSecurityGroupEgressInput{
@@ -665,11 +665,11 @@ func nukeSecurityGroups(client ec2iface.EC2API, vpcID string) error {
 					},
 				)
 				if err != nil {
-					pterm.Debug.Println(fmt.Sprintf("Failed to revoke security group egress rule: %s",
+					logging.Debug(fmt.Sprintf("Failed to revoke security group egress rule: %s",
 						awsgo.StringValue(securityGroupRule.SecurityGroupRuleId)))
 					return errors.WithStackTrace(err)
 				}
-				pterm.Debug.Println(fmt.Sprintf("Successfully revoked security group egress rule: %s",
+				logging.Debug(fmt.Sprintf("Successfully revoked security group egress rule: %s",
 					awsgo.StringValue(securityGroupRule.SecurityGroupRuleId)))
 			} else {
 				_, err := client.RevokeSecurityGroupIngress(
@@ -679,11 +679,11 @@ func nukeSecurityGroups(client ec2iface.EC2API, vpcID string) error {
 					},
 				)
 				if err != nil {
-					pterm.Debug.Println(fmt.Sprintf("Failed to revoke security group ingress rule: %s",
+					logging.Debug(fmt.Sprintf("Failed to revoke security group ingress rule: %s",
 						awsgo.StringValue(securityGroupRule.SecurityGroupRuleId)))
 					return errors.WithStackTrace(err)
 				}
-				pterm.Debug.Println(fmt.Sprintf("Successfully revoked security group ingress rule: %s",
+				logging.Debug(fmt.Sprintf("Successfully revoked security group ingress rule: %s",
 					awsgo.StringValue(securityGroupRule.SecurityGroupRuleId)))
 			}
 		}
@@ -697,11 +697,11 @@ func nukeSecurityGroups(client ec2iface.EC2API, vpcID string) error {
 				},
 			)
 			if err != nil {
-				pterm.Debug.Println(fmt.Sprintf(
+				logging.Debug(fmt.Sprintf(
 					"Successfully deleted security group %s", awsgo.StringValue(securityGroup.GroupId)))
 				return errors.WithStackTrace(err)
 			}
-			pterm.Debug.Println(fmt.Sprintf(
+			logging.Debug(fmt.Sprintf(
 				"Successfully deleted security group %s", awsgo.StringValue(securityGroup.GroupId)))
 		}
 	}
@@ -720,15 +720,15 @@ func nukeDhcpOptions(client ec2iface.EC2API, vpcID string) error {
 		},
 	)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to describe DHCP options associated with VPC w/ err: %s.", err))
+		logging.Debug(fmt.Sprintf("Failed to describe DHCP options associated with VPC w/ err: %s.", err))
 		return errors.WithStackTrace(err)
 	}
 
 	dhcpOptionID := vpcs.Vpcs[0].DhcpOptionsId
-	pterm.Debug.Println(fmt.Sprintf("Successfully found DHCP option associated with VPC: %s.", *dhcpOptionID))
+	logging.Debug(fmt.Sprintf("Successfully found DHCP option associated with VPC: %s.", *dhcpOptionID))
 
 	if *dhcpOptionID == "default" {
-		pterm.Debug.Println(fmt.Sprintf("No DHCP options to nuke. DHCP already set to default."))
+		logging.Debug(fmt.Sprintf("No DHCP options to nuke. DHCP already set to default."))
 		return nil
 	}
 
@@ -738,24 +738,24 @@ func nukeDhcpOptions(client ec2iface.EC2API, vpcID string) error {
 		VpcId:         awsgo.String(vpcID),
 	})
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to associate VPC with default set of DHCP options w/ err: %s.", err))
+		logging.Debug(fmt.Sprintf("Failed to associate VPC with default set of DHCP options w/ err: %s.", err))
 		return errors.WithStackTrace(err)
 	}
-	pterm.Debug.Println(fmt.Sprintf("Successfully associated VPC with default set of DHCP options."))
+	logging.Debug(fmt.Sprintf("Successfully associated VPC with default set of DHCP options."))
 	return err
 }
 
 func nukeVpc(client ec2iface.EC2API, vpcID string) error {
-	pterm.Debug.Println(fmt.Sprintf("Deleting VPC %s", vpcID))
+	logging.Debug(fmt.Sprintf("Deleting VPC %s", vpcID))
 	input := &ec2.DeleteVpcInput{
 		VpcId: awsgo.String(vpcID),
 	}
 	_, err := client.DeleteVpc(input)
 	if err != nil {
-		pterm.Debug.Println(fmt.Sprintf("Failed to delete VPC %s", vpcID))
+		logging.Debug(fmt.Sprintf("Failed to delete VPC %s", vpcID))
 		return errors.WithStackTrace(err)
 	}
 
-	pterm.Debug.Println(fmt.Sprintf("Successfully deleted VPC %s", vpcID))
+	logging.Debug(fmt.Sprintf("Successfully deleted VPC %s", vpcID))
 	return nil
 }
diff --git a/aws/resources/ecr.go b/aws/resources/ecr.go
index 837762a..77e5a98 100644
--- a/aws/resources/ecr.go
+++ b/aws/resources/ecr.go
@@ -38,7 +38,7 @@ func (registry *ECR) getAll(c context.Context, configObj config.Config) ([]*stri
 
 func (registry *ECR) nukeAll(repositoryNames []string) error {
 	if len(repositoryNames) == 0 {
-		logging.Logger.Debugf("No ECR repositories to nuke in region %s", registry.Region)
+		logging.Debugf("No ECR repositories to nuke in region %s", registry.Region)
 		return nil
 	}
 
@@ -66,15 +66,15 @@ func (registry *ECR) nukeAll(repositoryNames []string) error {
 			}, map[string]interface{}{
 				"region": registry.Region,
 			})
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 		} else {
 
 			deletedNames = append(deletedNames, aws.String(repositoryName))
-			logging.Logger.Debugf("Deleted ECR Repository: %s", repositoryName)
+			logging.Debugf("Deleted ECR Repository: %s", repositoryName)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d ECR Repositories deleted in %s", len(deletedNames), registry.Region)
+	logging.Debugf("[OK] %d ECR Repositories deleted in %s", len(deletedNames), registry.Region)
 
 	return nil
 }
diff --git a/aws/resources/ecs_cluster.go b/aws/resources/ecs_cluster.go
index e219c4e..f6f6511 100644
--- a/aws/resources/ecs_cluster.go
+++ b/aws/resources/ecs_cluster.go
@@ -51,7 +51,7 @@ func (clusters *ECSClusters) getAllEcsClusters() ([]*string, error) {
 func (clusters *ECSClusters) getAllActiveEcsClusterArns(configObj config.Config) ([]*string, error) {
 	allClusters, err := clusters.getAllEcsClusters()
 	if err != nil {
-		logging.Logger.Debug("Error getting all ECS clusters")
+		logging.Debug("Error getting all ECS clusters")
 		return nil, errors.WithStackTrace(err)
 	}
 
@@ -65,7 +65,7 @@ func (clusters *ECSClusters) getAllActiveEcsClusterArns(configObj config.Config)
 
 		describedClusters, describeErr := clusters.Client.DescribeClusters(input)
 		if describeErr != nil {
-			logging.Logger.Debugf("Error describing ECS clusters from input %s: ", input)
+			logging.Debugf("Error describing ECS clusters from input %s: ", input)
 			return nil, errors.WithStackTrace(describeErr)
 		}
 
@@ -87,7 +87,7 @@ func shouldIncludeECSCluster(cluster *ecs.Cluster, configObj config.Config) bool
 	// Filter out invalid state ECS Clusters (will return only `ACTIVE` state clusters)
 	// `cloud-nuke` needs to tag ECS Clusters it sees for the first time.
 	// Therefore to tag a cluster, that cluster must be in the `ACTIVE` state.
-	logging.Logger.Debugf("Status for ECS Cluster %s is %s", aws.StringValue(cluster.ClusterArn), aws.StringValue(cluster.Status))
+	logging.Debugf("Status for ECS Cluster %s is %s", aws.StringValue(cluster.ClusterArn), aws.StringValue(cluster.Status))
 	if aws.StringValue(cluster.Status) != activeEcsClusterStatus {
 		return false
 	}
@@ -98,7 +98,7 @@ func shouldIncludeECSCluster(cluster *ecs.Cluster, configObj config.Config) bool
 func (clusters *ECSClusters) getAll(c context.Context, configObj config.Config) ([]*string, error) {
 	clusterArns, err := clusters.getAllActiveEcsClusterArns(configObj)
 	if err != nil {
-		logging.Logger.Debugf("Error getting all ECS clusters with `ACTIVE` status")
+		logging.Debugf("Error getting all ECS clusters with `ACTIVE` status")
 		return nil, errors.WithStackTrace(err)
 	}
 
@@ -107,14 +107,14 @@ func (clusters *ECSClusters) getAll(c context.Context, configObj config.Config)
 
 		firstSeenTime, err := clusters.getFirstSeenTag(clusterArn)
 		if err != nil {
-			logging.Logger.Debugf("Error getting the `cloud-nuke-first-seen` tag for ECS cluster with ARN %s", aws.StringValue(clusterArn))
+			logging.Debugf("Error getting the `cloud-nuke-first-seen` tag for ECS cluster with ARN %s", aws.StringValue(clusterArn))
 			return nil, errors.WithStackTrace(err)
 		}
 
 		if firstSeenTime == nil {
 			err := clusters.setFirstSeenTag(clusterArn, time.Now().UTC())
 			if err != nil {
-				logging.Logger.Debugf("Error tagging the ECS cluster with ARN %s", aws.StringValue(clusterArn))
+				logging.Debugf("Error tagging the ECS cluster with ARN %s", aws.StringValue(clusterArn))
 				return nil, errors.WithStackTrace(err)
 			}
 		} else if configObj.ECSCluster.ShouldInclude(config.ResourceValue{Time: firstSeenTime}) {
@@ -128,11 +128,11 @@ func (clusters *ECSClusters) nukeAll(ecsClusterArns []*string) error {
 	numNuking := len(ecsClusterArns)
 
 	if numNuking == 0 {
-		logging.Logger.Debugf("No ECS clusters to nuke in region %s", clusters.Region)
+		logging.Debugf("No ECS clusters to nuke in region %s", clusters.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting %d ECS clusters in region %s", numNuking, clusters.Region)
+	logging.Debugf("Deleting %d ECS clusters in region %s", numNuking, clusters.Region)
 
 	var nukedEcsClusters []*string
 	for _, clusterArn := range ecsClusterArns {
@@ -150,7 +150,7 @@ func (clusters *ECSClusters) nukeAll(ecsClusterArns []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("Error, failed to delete cluster with ARN %s", aws.StringValue(clusterArn))
+			logging.Debugf("Error, failed to delete cluster with ARN %s", aws.StringValue(clusterArn))
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ECS Cluster",
 			}, map[string]interface{}{
@@ -159,12 +159,12 @@ func (clusters *ECSClusters) nukeAll(ecsClusterArns []*string) error {
 			return errors.WithStackTrace(err)
 		}
 
-		logging.Logger.Debugf("Success, deleted cluster: %s", aws.StringValue(clusterArn))
+		logging.Debugf("Success, deleted cluster: %s", aws.StringValue(clusterArn))
 		nukedEcsClusters = append(nukedEcsClusters, clusterArn)
 	}
 
 	numNuked := len(nukedEcsClusters)
-	logging.Logger.Debugf("[OK] %d of %d ECS cluster(s) deleted in %s", numNuked, numNuking, clusters.Region)
+	logging.Debugf("[OK] %d of %d ECS cluster(s) deleted in %s", numNuked, numNuking, clusters.Region)
 
 	return nil
 }
@@ -201,7 +201,7 @@ func (clusters *ECSClusters) getFirstSeenTag(clusterArn *string) (*time.Time, er
 
 	clusterTags, err := clusters.Client.ListTagsForResource(input)
 	if err != nil {
-		logging.Logger.Debugf("Error getting the tags for ECS cluster with ARN %s", aws.StringValue(clusterArn))
+		logging.Debugf("Error getting the tags for ECS cluster with ARN %s", aws.StringValue(clusterArn))
 		return firstSeenTime, errors.WithStackTrace(err)
 	}
 
@@ -210,7 +210,7 @@ func (clusters *ECSClusters) getFirstSeenTag(clusterArn *string) (*time.Time, er
 
 			firstSeenTime, err := util.ParseTimestampTag(tag.Value)
 			if err != nil {
-				logging.Logger.Debugf("Error parsing the `cloud-nuke-first-seen` tag for ECS cluster with ARN %s", aws.StringValue(clusterArn))
+				logging.Debugf("Error parsing the `cloud-nuke-first-seen` tag for ECS cluster with ARN %s", aws.StringValue(clusterArn))
 				return firstSeenTime, errors.WithStackTrace(err)
 			}
 
diff --git a/aws/resources/ecs_service.go b/aws/resources/ecs_service.go
index a4bd8c0..ccdfb76 100644
--- a/aws/resources/ecs_service.go
+++ b/aws/resources/ecs_service.go
@@ -115,7 +115,7 @@ func (services *ECSServices) drainEcsServices(ecsServiceArns []*string) []*strin
 		}
 		describeServicesOutput, err := services.Client.DescribeServices(describeParams)
 		if err != nil {
-			logging.Logger.Errorf("[Failed] Failed to describe service %s: %s", *ecsServiceArn, err)
+			logging.Errorf("[Failed] Failed to describe service %s: %s", *ecsServiceArn, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ECS Service",
 			}, map[string]interface{}{
@@ -135,7 +135,7 @@ func (services *ECSServices) drainEcsServices(ecsServiceArns []*string) []*strin
 				}
 				_, err = services.Client.UpdateService(params)
 				if err != nil {
-					logging.Logger.Errorf("[Failed] Failed to drain service %s: %s", *ecsServiceArn, err)
+					logging.Errorf("[Failed] Failed to drain service %s: %s", *ecsServiceArn, err)
 					telemetry.TrackEvent(commonTelemetry.EventContext{
 						EventName: "Error Nuking ECS Service",
 					}, map[string]interface{}{
@@ -164,7 +164,7 @@ func (services *ECSServices) waitUntilServicesDrained(ecsServiceArns []*string)
 		}
 		err := services.Client.WaitUntilServicesStable(params)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed waiting for service to be stable %s: %s", *ecsServiceArn, err)
+			logging.Debugf("[Failed] Failed waiting for service to be stable %s: %s", *ecsServiceArn, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ECS Service",
 			}, map[string]interface{}{
@@ -172,7 +172,7 @@ func (services *ECSServices) waitUntilServicesDrained(ecsServiceArns []*string)
 				"reason": "Failed Waiting for Drain",
 			})
 		} else {
-			logging.Logger.Debugf("Drained service: %s", *ecsServiceArn)
+			logging.Debugf("Drained service: %s", *ecsServiceArn)
 			successfullyDrained = append(successfullyDrained, ecsServiceArn)
 		}
 	}
@@ -190,7 +190,7 @@ func (services *ECSServices) deleteEcsServices(ecsServiceArns []*string) []*stri
 		}
 		_, err := services.Client.DeleteService(params)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed deleting service %s: %s", *ecsServiceArn, err)
+			logging.Debugf("[Failed] Failed deleting service %s: %s", *ecsServiceArn, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ECS Service",
 			}, map[string]interface{}{
@@ -225,7 +225,7 @@ func (services *ECSServices) waitUntilServicesDeleted(ecsServiceArns []*string)
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed waiting for service to be deleted %s: %s", *ecsServiceArn, err)
+			logging.Debugf("[Failed] Failed waiting for service to be deleted %s: %s", *ecsServiceArn, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking ECS Service",
 			}, map[string]interface{}{
@@ -233,7 +233,7 @@ func (services *ECSServices) waitUntilServicesDeleted(ecsServiceArns []*string)
 				"reason": "Failed Waiting for Delete",
 			})
 		} else {
-			logging.Logger.Debugf("Deleted service: %s", *ecsServiceArn)
+			logging.Debugf("Deleted service: %s", *ecsServiceArn)
 			successfullyDeleted = append(successfullyDeleted, ecsServiceArn)
 		}
 	}
@@ -251,11 +251,11 @@ func (services *ECSServices) waitUntilServicesDeleted(ecsServiceArns []*string)
 func (services *ECSServices) nukeAll(ecsServiceArns []*string) error {
 	numNuking := len(ecsServiceArns)
 	if numNuking == 0 {
-		logging.Logger.Debugf("No ECS services to nuke in region %s", services.Region)
+		logging.Debugf("No ECS services to nuke in region %s", services.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting %d ECS services in region %s", numNuking, services.Region)
+	logging.Debugf("Deleting %d ECS services in region %s", numNuking, services.Region)
 
 	// First, drain all the services to 0. You can't delete a
 	// service that is running tasks.
@@ -269,6 +269,6 @@ func (services *ECSServices) nukeAll(ecsServiceArns []*string) error {
 	successfullyDeleted := services.waitUntilServicesDeleted(requestedDeletes)
 
 	numNuked := len(successfullyDeleted)
-	logging.Logger.Debugf("[OK] %d of %d ECS service(s) deleted in %s", numNuked, numNuking, services.Client)
+	logging.Debugf("[OK] %d of %d ECS service(s) deleted in %s", numNuked, numNuking, services.Client)
 	return nil
 }
diff --git a/aws/resources/efs.go b/aws/resources/efs.go
index b0b9a56..99e00b1 100644
--- a/aws/resources/efs.go
+++ b/aws/resources/efs.go
@@ -37,16 +37,16 @@ func (ef *ElasticFileSystem) getAll(c context.Context, configObj config.Config)
 
 func (ef *ElasticFileSystem) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No Elastic FileSystems (efs) to nuke in region %s", ef.Region)
+		logging.Debugf("No Elastic FileSystems (efs) to nuke in region %s", ef.Region)
 	}
 
 	if len(identifiers) > 100 {
-		logging.Logger.Debugf("Nuking too many Elastic FileSystems (100): halting to avoid hitting AWS API rate limiting")
+		logging.Debugf("Nuking too many Elastic FileSystems (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyElasticFileSystemsErr{}
 	}
 
 	// There is no bulk delete EFS API, so we delete the batch of Elastic FileSystems concurrently using goroutines
-	logging.Logger.Debugf("Deleting Elastic FileSystems (efs) in region %s", ef.Region)
+	logging.Debugf("Deleting Elastic FileSystems (efs) in region %s", ef.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -60,7 +60,7 @@ func (ef *ElasticFileSystem) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking EFS",
 			}, map[string]interface{}{
@@ -105,13 +105,13 @@ func (ef *ElasticFileSystem) deleteAsync(wg *sync.WaitGroup, errChan chan error,
 			AccessPointId: apID,
 		}
 
-		logging.Logger.Debugf("Deleting access point (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(apID), aws.StringValue(efsID), ef.Region)
+		logging.Debugf("Deleting access point (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(apID), aws.StringValue(efsID), ef.Region)
 
 		_, err := ef.Client.DeleteAccessPoint(deleteParam)
 		if err != nil {
 			allErrs = multierror.Append(allErrs, err)
 		} else {
-			logging.Logger.Debugf("[OK] Deleted access point (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(apID), aws.StringValue(efsID), ef.Region)
+			logging.Debugf("[OK] Deleted access point (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(apID), aws.StringValue(efsID), ef.Region)
 		}
 	}
 
@@ -158,17 +158,17 @@ func (ef *ElasticFileSystem) deleteAsync(wg *sync.WaitGroup, errChan chan error,
 			MountTargetId: mtID,
 		}
 
-		logging.Logger.Debugf("Deleting mount target (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(mtID), aws.StringValue(efsID), ef.Region)
+		logging.Debugf("Deleting mount target (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(mtID), aws.StringValue(efsID), ef.Region)
 
 		_, err := ef.Client.DeleteMountTarget(deleteMtParam)
 		if err != nil {
 			allErrs = multierror.Append(allErrs, err)
 		} else {
-			logging.Logger.Debugf("[OK] Deleted mount target (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(mtID), aws.StringValue(efsID), ef.Region)
+			logging.Debugf("[OK] Deleted mount target (id=%s) for Elastic FileSystem (%s) in region: %s", aws.StringValue(mtID), aws.StringValue(efsID), ef.Region)
 		}
 	}
 
-	logging.Logger.Debug("Sleeping 20 seconds to allow AWS to realize the Elastic FileSystem is no longer in use...")
+	logging.Debug("Sleeping 20 seconds to allow AWS to realize the Elastic FileSystem is no longer in use...")
 	time.Sleep(20 * time.Second)
 
 	// Now we can attempt to delete the Elastic FileSystem itself
@@ -190,8 +190,8 @@ func (ef *ElasticFileSystem) deleteAsync(wg *sync.WaitGroup, errChan chan error,
 	}
 
 	if err == nil {
-		logging.Logger.Debugf("[OK] Elastic FileSystem (efs) %s deleted in %s", aws.StringValue(efsID), ef.Region)
+		logging.Debugf("[OK] Elastic FileSystem (efs) %s deleted in %s", aws.StringValue(efsID), ef.Region)
 	} else {
-		logging.Logger.Debugf("[Failed] Error deleting Elastic FileSystem (efs) %s in %s", aws.StringValue(efsID), ef.Region)
+		logging.Debugf("[Failed] Error deleting Elastic FileSystem (efs) %s in %s", aws.StringValue(efsID), ef.Region)
 	}
 }
diff --git a/aws/resources/eip.go b/aws/resources/eip.go
index 7278983..14bd7b9 100644
--- a/aws/resources/eip.go
+++ b/aws/resources/eip.go
@@ -94,11 +94,11 @@ func (ea *EIPAddresses) shouldInclude(address *ec2.Address, firstSeenTime time.T
 // Deletes all EIP allocation ids
 func (ea *EIPAddresses) nukeAll(allocationIds []*string) error {
 	if len(allocationIds) == 0 {
-		logging.Logger.Debugf("No Elastic IPs to nuke in region %s", ea.Region)
+		logging.Debugf("No Elastic IPs to nuke in region %s", ea.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Elastic IPs in region %s", ea.Region)
+	logging.Debugf("Deleting all Elastic IPs in region %s", ea.Region)
 	var deletedAllocationIDs []*string
 
 	for _, allocationID := range allocationIds {
@@ -119,7 +119,7 @@ func (ea *EIPAddresses) nukeAll(allocationIds []*string) error {
 		if err != nil {
 			if awsErr, isAwsErr := err.(awserr.Error); isAwsErr && awsErr.Code() == "AuthFailure" {
 				// TODO: Figure out why we get an AuthFailure
-				logging.Logger.Debugf("EIP %s can't be deleted, it is still attached to an active resource", *allocationID)
+				logging.Debugf("EIP %s can't be deleted, it is still attached to an active resource", *allocationID)
 				telemetry.TrackEvent(commonTelemetry.EventContext{
 					EventName: "Error Nuking EIP",
 				}, map[string]interface{}{
@@ -127,7 +127,7 @@ func (ea *EIPAddresses) nukeAll(allocationIds []*string) error {
 					"reason": "Still Attached to an Active Resource",
 				})
 			} else {
-				logging.Logger.Debugf("[Failed] %s", err)
+				logging.Debugf("[Failed] %s", err)
 				telemetry.TrackEvent(commonTelemetry.EventContext{
 					EventName: "Error Nuking EIP",
 				}, map[string]interface{}{
@@ -136,10 +136,10 @@ func (ea *EIPAddresses) nukeAll(allocationIds []*string) error {
 			}
 		} else {
 			deletedAllocationIDs = append(deletedAllocationIDs, allocationID)
-			logging.Logger.Debugf("Deleted Elastic IP: %s", *allocationID)
+			logging.Debugf("Deleted Elastic IP: %s", *allocationID)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Elastic IP(s) deleted in %s", len(deletedAllocationIDs), ea.Region)
+	logging.Debugf("[OK] %d Elastic IP(s) deleted in %s", len(deletedAllocationIDs), ea.Region)
 	return nil
 }
diff --git a/aws/resources/eks.go b/aws/resources/eks.go
index 5c48480..c9c1dc0 100644
--- a/aws/resources/eks.go
+++ b/aws/resources/eks.go
@@ -87,10 +87,10 @@ func (clusters *EKSClusters) deleteAsync(wg *sync.WaitGroup, errChan chan error,
 			NodegroupName: nodeGroup,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed waiting for Node Group %s associated with cluster %s to be deleted: %s", aws.StringValue(nodeGroup), eksClusterName, err)
+			logging.Debugf("[Failed] Failed waiting for Node Group %s associated with cluster %s to be deleted: %s", aws.StringValue(nodeGroup), eksClusterName, err)
 			allSubResourceErrs = multierror.Append(allSubResourceErrs, err)
 		} else {
-			logging.Logger.Debugf("Deleted Node Group %s associated with cluster %s", aws.StringValue(nodeGroup), eksClusterName)
+			logging.Debugf("Deleted Node Group %s associated with cluster %s", aws.StringValue(nodeGroup), eksClusterName)
 		}
 	}
 	if allSubResourceErrs != nil {
@@ -102,7 +102,7 @@ func (clusters *EKSClusters) deleteAsync(wg *sync.WaitGroup, errChan chan error,
 	// request to delete the EKS cluster.
 	_, deleteErr := clusters.Client.DeleteCluster(&eks.DeleteClusterInput{Name: aws.String(eksClusterName)})
 	if deleteErr != nil {
-		logging.Logger.Debugf("[Failed] Failed deleting EKS cluster %s: %s", eksClusterName, deleteErr)
+		logging.Debugf("[Failed] Failed deleting EKS cluster %s: %s", eksClusterName, deleteErr)
 	}
 	errChan <- deleteErr
 }
@@ -135,7 +135,7 @@ func (clusters *EKSClusters) scheduleDeleteEKSClusterManagedNodeGroup(eksCluster
 			NodegroupName: nodeGroup,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed deleting Node Group %s associated with cluster %s: %s", aws.StringValue(nodeGroup), eksClusterName, err)
+			logging.Debugf("[Failed] Failed deleting Node Group %s associated with cluster %s: %s", aws.StringValue(nodeGroup), eksClusterName, err)
 			allDeleteErrs = multierror.Append(allDeleteErrs, err)
 		} else {
 			deletedNodeGroups = append(deletedNodeGroups, nodeGroup)
@@ -173,7 +173,7 @@ func (clusters *EKSClusters) deleteEKSClusterFargateProfiles(eksClusterName stri
 			FargateProfileName: fargateProfile,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed deleting Fargate Profile %s associated with cluster %s: %s", aws.StringValue(fargateProfile), eksClusterName, err)
+			logging.Debugf("[Failed] Failed deleting Fargate Profile %s associated with cluster %s: %s", aws.StringValue(fargateProfile), eksClusterName, err)
 			allDeleteErrs = multierror.Append(allDeleteErrs, err)
 			continue
 		}
@@ -183,10 +183,10 @@ func (clusters *EKSClusters) deleteEKSClusterFargateProfiles(eksClusterName stri
 			FargateProfileName: fargateProfile,
 		})
 		if waitErr != nil {
-			logging.Logger.Debugf("[Failed] Failed waiting for Fargate Profile %s associated with cluster %s to be deleted: %s", aws.StringValue(fargateProfile), eksClusterName, waitErr)
+			logging.Debugf("[Failed] Failed waiting for Fargate Profile %s associated with cluster %s to be deleted: %s", aws.StringValue(fargateProfile), eksClusterName, waitErr)
 			allDeleteErrs = multierror.Append(allDeleteErrs, waitErr)
 		} else {
-			logging.Logger.Debugf("Deleted Fargate Profile %s associated with cluster %s", aws.StringValue(fargateProfile), eksClusterName)
+			logging.Debugf("Deleted Fargate Profile %s associated with cluster %s", aws.StringValue(fargateProfile), eksClusterName)
 		}
 	}
 	return allDeleteErrs
@@ -208,9 +208,9 @@ func (clusters *EKSClusters) waitUntilEksClustersDeleted(eksClusterNames []*stri
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] Failed waiting for EKS cluster to be deleted %s: %s", *eksClusterName, err)
+			logging.Debugf("[Failed] Failed waiting for EKS cluster to be deleted %s: %s", *eksClusterName, err)
 		} else {
-			logging.Logger.Debugf("Deleted EKS cluster: %s", aws.StringValue(eksClusterName))
+			logging.Debugf("Deleted EKS cluster: %s", aws.StringValue(eksClusterName))
 			successfullyDeleted = append(successfullyDeleted, eksClusterName)
 		}
 	}
@@ -221,7 +221,7 @@ func (clusters *EKSClusters) waitUntilEksClustersDeleted(eksClusterNames []*stri
 func (clusters *EKSClusters) nukeAll(eksClusterNames []*string) error {
 	numNuking := len(eksClusterNames)
 	if numNuking == 0 {
-		logging.Logger.Debugf("No EKS clusters to nuke in region %s", clusters.Region)
+		logging.Debugf("No EKS clusters to nuke in region %s", clusters.Region)
 		return nil
 	}
 
@@ -230,13 +230,13 @@ func (clusters *EKSClusters) nukeAll(eksClusterNames []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if numNuking > 100 {
-		logging.Logger.Debugf("Nuking too many EKS Clusters at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Debugf("Nuking too many EKS Clusters at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyEKSClustersErr{}
 	}
 
 	// We need to delete subresources associated with the EKS Cluster before being able to delete the cluster, so we
 	// spawn goroutines to drive the deletion of each EKS cluster.
-	logging.Logger.Debugf("Deleting %d EKS clusters in region %s", numNuking, clusters.Region)
+	logging.Debugf("Deleting %d EKS clusters in region %s", numNuking, clusters.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(numNuking)
 	errChans := make([]chan error, numNuking)
@@ -251,7 +251,7 @@ func (clusters *EKSClusters) nukeAll(eksClusterNames []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking EKS Cluster",
 			}, map[string]interface{}{
@@ -267,7 +267,7 @@ func (clusters *EKSClusters) nukeAll(eksClusterNames []*string) error {
 	// Now wait until the EKS Clusters are deleted
 	successfullyDeleted := clusters.waitUntilEksClustersDeleted(eksClusterNames)
 	numNuked := len(successfullyDeleted)
-	logging.Logger.Debugf("[OK] %d of %d EKS cluster(s) deleted in %s", numNuked, numNuking, clusters.Region)
+	logging.Debugf("[OK] %d of %d EKS cluster(s) deleted in %s", numNuked, numNuking, clusters.Region)
 	return nil
 }
 
diff --git a/aws/resources/elasticache.go b/aws/resources/elasticache.go
index 10a4e99..ba249a2 100644
--- a/aws/resources/elasticache.go
+++ b/aws/resources/elasticache.go
@@ -108,7 +108,7 @@ func (cache *Elasticaches) determineCacheClusterType(clusterId *string) (*string
 }
 
 func (cache *Elasticaches) nukeNonReplicationGroupElasticacheCluster(clusterId *string) error {
-	logging.Logger.Debugf("Deleting Elasticache cluster Id: %s which is not a member of a replication group", aws.StringValue(clusterId))
+	logging.Debugf("Deleting Elasticache cluster Id: %s which is not a member of a replication group", aws.StringValue(clusterId))
 	params := elasticache.DeleteCacheClusterInput{
 		CacheClusterId: clusterId,
 	}
@@ -123,7 +123,7 @@ func (cache *Elasticaches) nukeNonReplicationGroupElasticacheCluster(clusterId *
 }
 
 func (cache *Elasticaches) nukeReplicationGroupMemberElasticacheCluster(clusterId *string) error {
-	logging.Logger.Debugf("Elasticache cluster Id: %s is a member of a replication group. Therefore, deleting its replication group", aws.StringValue(clusterId))
+	logging.Debugf("Elasticache cluster Id: %s is a member of a replication group. Therefore, deleting its replication group", aws.StringValue(clusterId))
 
 	params := &elasticache.DeleteReplicationGroupInput{
 		ReplicationGroupId: clusterId,
@@ -141,18 +141,18 @@ func (cache *Elasticaches) nukeReplicationGroupMemberElasticacheCluster(clusterI
 		return waitErr
 	}
 
-	logging.Logger.Debugf("Successfully deleted replication group Id: %s", aws.StringValue(clusterId))
+	logging.Debugf("Successfully deleted replication group Id: %s", aws.StringValue(clusterId))
 
 	return nil
 }
 
 func (cache *Elasticaches) nukeAll(clusterIds []*string) error {
 	if len(clusterIds) == 0 {
-		logging.Logger.Debugf("No Elasticache clusters to nuke in region %s", cache.Region)
+		logging.Debugf("No Elasticache clusters to nuke in region %s", cache.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting %d Elasticache clusters in region %s", len(clusterIds), cache.Region)
+	logging.Debugf("Deleting %d Elasticache clusters in region %s", len(clusterIds), cache.Region)
 
 	var deletedClusterIds []*string
 	for _, clusterId := range clusterIds {
@@ -181,7 +181,7 @@ func (cache *Elasticaches) nukeAll(clusterIds []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Elasticache Cluster",
 			}, map[string]interface{}{
@@ -189,11 +189,11 @@ func (cache *Elasticaches) nukeAll(clusterIds []*string) error {
 			})
 		} else {
 			deletedClusterIds = append(deletedClusterIds, clusterId)
-			logging.Logger.Debugf("Deleted Elasticache cluster: %s", *clusterId)
+			logging.Debugf("Deleted Elasticache cluster: %s", *clusterId)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Elasticache clusters deleted in %s", len(deletedClusterIds), cache.Region)
+	logging.Debugf("[OK] %d Elasticache clusters deleted in %s", len(deletedClusterIds), cache.Region)
 	return nil
 }
 
@@ -244,7 +244,7 @@ func (pg *ElasticacheParameterGroups) shouldInclude(paramGroup *elasticache.Cach
 
 func (pg *ElasticacheParameterGroups) nukeAll(paramGroupNames []*string) error {
 	if len(paramGroupNames) == 0 {
-		logging.Logger.Debugf("No Elasticache parameter groups to nuke in region %s", pg.Region)
+		logging.Debugf("No Elasticache parameter groups to nuke in region %s", pg.Region)
 		return nil
 	}
 	var deletedGroupNames []*string
@@ -259,7 +259,7 @@ func (pg *ElasticacheParameterGroups) nukeAll(paramGroupNames []*string) error {
 		}
 		report.Record(e)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Elasticache Parameter Group",
 			}, map[string]interface{}{
@@ -267,10 +267,10 @@ func (pg *ElasticacheParameterGroups) nukeAll(paramGroupNames []*string) error {
 			})
 		} else {
 			deletedGroupNames = append(deletedGroupNames, pgName)
-			logging.Logger.Debugf("Deleted Elasticache parameter group: %s", aws.StringValue(pgName))
+			logging.Debugf("Deleted Elasticache parameter group: %s", aws.StringValue(pgName))
 		}
 	}
-	logging.Logger.Debugf("[OK] %d Elasticache parameter groups deleted in %s", len(deletedGroupNames), pg.Region)
+	logging.Debugf("[OK] %d Elasticache parameter groups deleted in %s", len(deletedGroupNames), pg.Region)
 	return nil
 }
 
@@ -300,7 +300,7 @@ func (sg *ElasticacheSubnetGroups) getAll(c context.Context, configObj config.Co
 
 func (sg *ElasticacheSubnetGroups) nukeAll(subnetGroupNames []*string) error {
 	if len(subnetGroupNames) == 0 {
-		logging.Logger.Debugf("No Elasticache subnet groups to nuke in region %s", sg.Region)
+		logging.Debugf("No Elasticache subnet groups to nuke in region %s", sg.Region)
 		return nil
 	}
 	var deletedGroupNames []*string
@@ -315,7 +315,7 @@ func (sg *ElasticacheSubnetGroups) nukeAll(subnetGroupNames []*string) error {
 		}
 		report.Record(e)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Elasticache Subnet Group",
 			}, map[string]interface{}{
@@ -323,9 +323,9 @@ func (sg *ElasticacheSubnetGroups) nukeAll(subnetGroupNames []*string) error {
 			})
 		} else {
 			deletedGroupNames = append(deletedGroupNames, sgName)
-			logging.Logger.Debugf("Deleted Elasticache subnet group: %s", aws.StringValue(sgName))
+			logging.Debugf("Deleted Elasticache subnet group: %s", aws.StringValue(sgName))
 		}
 	}
-	logging.Logger.Debugf("[OK] %d Elasticache subnet groups deleted in %s", len(deletedGroupNames), sg.Region)
+	logging.Debugf("[OK] %d Elasticache subnet groups deleted in %s", len(deletedGroupNames), sg.Region)
 	return nil
 }
diff --git a/aws/resources/elb.go b/aws/resources/elb.go
index b6fbee3..74f68a0 100644
--- a/aws/resources/elb.go
+++ b/aws/resources/elb.go
@@ -27,7 +27,7 @@ func (balancer *LoadBalancers) waitUntilElbDeleted(input *elb.DescribeLoadBalanc
 		}
 
 		time.Sleep(1 * time.Second)
-		logging.Logger.Debug("Waiting for ELB to be deleted")
+		logging.Debug("Waiting for ELB to be deleted")
 	}
 
 	return ElbDeleteError{}
@@ -56,11 +56,11 @@ func (balancer *LoadBalancers) getAll(c context.Context, configObj config.Config
 // Deletes all Elastic Load Balancers
 func (balancer *LoadBalancers) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No Elastic Load Balancers to nuke in region %s", balancer.Region)
+		logging.Debugf("No Elastic Load Balancers to nuke in region %s", balancer.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Elastic Load Balancers in region %s", balancer.Region)
+	logging.Debugf("Deleting all Elastic Load Balancers in region %s", balancer.Region)
 	var deletedNames []*string
 
 	for _, name := range names {
@@ -79,7 +79,7 @@ func (balancer *LoadBalancers) nukeAll(names []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Load Balancer (v1)",
 			}, map[string]interface{}{
@@ -87,7 +87,7 @@ func (balancer *LoadBalancers) nukeAll(names []*string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted ELB: %s", *name)
+			logging.Debugf("Deleted ELB: %s", *name)
 		}
 	}
 
@@ -96,11 +96,11 @@ func (balancer *LoadBalancers) nukeAll(names []*string) error {
 			LoadBalancerNames: deletedNames,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Elastic Load Balancer(s) deleted in %s", len(deletedNames), balancer.Region)
+	logging.Debugf("[OK] %d Elastic Load Balancer(s) deleted in %s", len(deletedNames), balancer.Region)
 	return nil
 }
diff --git a/aws/resources/elbv2.go b/aws/resources/elbv2.go
index 6c3ce7d..f7a48a2 100644
--- a/aws/resources/elbv2.go
+++ b/aws/resources/elbv2.go
@@ -35,11 +35,11 @@ func (balancer *LoadBalancersV2) getAll(c context.Context, configObj config.Conf
 // Deletes all Elastic Load Balancers
 func (balancer *LoadBalancersV2) nukeAll(arns []*string) error {
 	if len(arns) == 0 {
-		logging.Logger.Debugf("No V2 Elastic Load Balancers to nuke in region %s", balancer.Region)
+		logging.Debugf("No V2 Elastic Load Balancers to nuke in region %s", balancer.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all V2 Elastic Load Balancers in region %s", balancer.Region)
+	logging.Debugf("Deleting all V2 Elastic Load Balancers in region %s", balancer.Region)
 	var deletedArns []*string
 
 	for _, arn := range arns {
@@ -58,7 +58,7 @@ func (balancer *LoadBalancersV2) nukeAll(arns []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Load Balancer V2",
 			}, map[string]interface{}{
@@ -66,7 +66,7 @@ func (balancer *LoadBalancersV2) nukeAll(arns []*string) error {
 			})
 		} else {
 			deletedArns = append(deletedArns, arn)
-			logging.Logger.Debugf("Deleted ELBv2: %s", *arn)
+			logging.Debugf("Deleted ELBv2: %s", *arn)
 		}
 	}
 
@@ -75,11 +75,11 @@ func (balancer *LoadBalancersV2) nukeAll(arns []*string) error {
 			LoadBalancerArns: deletedArns,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d V2 Elastic Load Balancer(s) deleted in %s", len(deletedArns), balancer.Region)
+	logging.Debugf("[OK] %d V2 Elastic Load Balancer(s) deleted in %s", len(deletedArns), balancer.Region)
 	return nil
 }
diff --git a/aws/resources/guardduty.go b/aws/resources/guardduty.go
index 1e3d37e..d391440 100644
--- a/aws/resources/guardduty.go
+++ b/aws/resources/guardduty.go
@@ -53,7 +53,7 @@ func (gd *GuardDuty) shouldInclude(detector *guardduty.GetDetectorOutput, detect
 	detectorCreatedAt := aws.StringValue(detector.CreatedAt)
 	createdAtDateTime, err := time.Parse(time.RFC3339, detectorCreatedAt)
 	if err != nil {
-		logging.Logger.Debugf("Could not parse createdAt timestamp (%s) of GuardDuty detector %s. Excluding from delete.", detectorCreatedAt, *detectorId)
+		logging.Debugf("Could not parse createdAt timestamp (%s) of GuardDuty detector %s. Excluding from delete.", detectorCreatedAt, *detectorId)
 	}
 
 	return configObj.GuardDuty.ShouldInclude(config.ResourceValue{Time: &createdAtDateTime})
@@ -61,12 +61,12 @@ func (gd *GuardDuty) shouldInclude(detector *guardduty.GetDetectorOutput, detect
 
 func (gd *GuardDuty) nukeAll(detectorIds []string) error {
 	if len(detectorIds) == 0 {
-		logging.Logger.Debugf("No GuardDuty detectors to nuke in region %s", gd.Region)
+		logging.Debugf("No GuardDuty detectors to nuke in region %s", gd.Region)
 
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all GuardDuty detectors in region %s", gd.Region)
+	logging.Debugf("Deleting all GuardDuty detectors in region %s", gd.Region)
 
 	deletedIds := []string{}
 
@@ -86,7 +86,7 @@ func (gd *GuardDuty) nukeAll(detectorIds []string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s: %s", detectorId, err)
+			logging.Debugf("[Failed] %s: %s", detectorId, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking GuardDuty Detector",
 			}, map[string]interface{}{
@@ -94,10 +94,10 @@ func (gd *GuardDuty) nukeAll(detectorIds []string) error {
 			})
 		} else {
 			deletedIds = append(deletedIds, detectorId)
-			logging.Logger.Debugf("Deleted GuardDuty detector: %s", detectorId)
+			logging.Debugf("Deleted GuardDuty detector: %s", detectorId)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d GuardDuty Detector(s) deleted in %s", len(deletedIds), gd.Region)
+	logging.Debugf("[OK] %d GuardDuty Detector(s) deleted in %s", len(deletedIds), gd.Region)
 	return nil
 }
diff --git a/aws/resources/iam.go b/aws/resources/iam.go
index 07fc7c1..09980d1 100644
--- a/aws/resources/iam.go
+++ b/aws/resources/iam.go
@@ -56,10 +56,10 @@ func (iu *IAMUsers) detachUserPolicies(userName *string) error {
 			UserName:  userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
-		logging.Logger.Debugf("Detached Policy %s from User %s", aws.StringValue(arn), aws.StringValue(userName))
+		logging.Debugf("Detached Policy %s from User %s", aws.StringValue(arn), aws.StringValue(userName))
 	}
 
 	return nil
@@ -70,7 +70,7 @@ func (iu *IAMUsers) deleteInlineUserPolicies(userName *string) error {
 		UserName: userName,
 	})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] %s", err)
+		logging.Errorf("[Failed] %s", err)
 		return errors.WithStackTrace(err)
 	}
 
@@ -80,10 +80,10 @@ func (iu *IAMUsers) deleteInlineUserPolicies(userName *string) error {
 			UserName:   userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
-		logging.Logger.Debugf("Deleted Inline Policy %s from User %s", aws.StringValue(policyName), aws.StringValue(userName))
+		logging.Debugf("Deleted Inline Policy %s from User %s", aws.StringValue(policyName), aws.StringValue(userName))
 	}
 
 	return nil
@@ -103,10 +103,10 @@ func (iu *IAMUsers) removeUserFromGroups(userName *string) error {
 			UserName:  userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
-		logging.Logger.Debugf("Removed user %s from group %s", aws.StringValue(userName), aws.StringValue(group.GroupName))
+		logging.Debugf("Removed user %s from group %s", aws.StringValue(userName), aws.StringValue(group.GroupName))
 	}
 
 	return nil
@@ -141,7 +141,7 @@ func (iu *IAMUsers) deleteLoginProfile(userName *string) error {
 				}
 			}
 
-			logging.Logger.Debugf("Deleted Login Profile from user %s", aws.StringValue(userName))
+			logging.Debugf("Deleted Login Profile from user %s", aws.StringValue(userName))
 			return nil
 		})
 }
@@ -151,7 +151,7 @@ func (iu *IAMUsers) deleteAccessKeys(userName *string) error {
 		UserName: userName,
 	})
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		return errors.WithStackTrace(err)
 	}
 
@@ -162,11 +162,11 @@ func (iu *IAMUsers) deleteAccessKeys(userName *string) error {
 			UserName:    userName,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 
-		logging.Logger.Debugf("Deleted Access Key %s from user %s", aws.StringValue(accessKeyId), aws.StringValue(userName))
+		logging.Debugf("Deleted Access Key %s from user %s", aws.StringValue(accessKeyId), aws.StringValue(userName))
 	}
 
 	return nil
@@ -177,7 +177,7 @@ func (iu *IAMUsers) deleteSigningCertificate(userName *string) error {
 		UserName: userName,
 	})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] %s", err)
+		logging.Errorf("[Failed] %s", err)
 		return errors.WithStackTrace(err)
 	}
 
@@ -188,11 +188,11 @@ func (iu *IAMUsers) deleteSigningCertificate(userName *string) error {
 			UserName:      userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 
-		logging.Logger.Debugf("Deleted Signing Certificate ID %s from user %s", aws.StringValue(certificateId), aws.StringValue(userName))
+		logging.Debugf("Deleted Signing Certificate ID %s from user %s", aws.StringValue(certificateId), aws.StringValue(userName))
 	}
 
 	return nil
@@ -203,7 +203,7 @@ func (iu *IAMUsers) deleteSSHPublicKeys(userName *string) error {
 		UserName: userName,
 	})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] %s", err)
+		logging.Errorf("[Failed] %s", err)
 		return errors.WithStackTrace(err)
 	}
 
@@ -214,11 +214,11 @@ func (iu *IAMUsers) deleteSSHPublicKeys(userName *string) error {
 			UserName:       userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 
-		logging.Logger.Debugf("Deleted SSH Public Key with ID %s from user %s", aws.StringValue(keyId), aws.StringValue(userName))
+		logging.Debugf("Deleted SSH Public Key with ID %s from user %s", aws.StringValue(keyId), aws.StringValue(userName))
 	}
 
 	return nil
@@ -235,7 +235,7 @@ func (iu *IAMUsers) deleteServiceSpecificCredentials(userName *string) error {
 			UserName:    userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 
@@ -247,11 +247,11 @@ func (iu *IAMUsers) deleteServiceSpecificCredentials(userName *string) error {
 				UserName:                    userName,
 			})
 			if err != nil {
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				return errors.WithStackTrace(err)
 			}
 
-			logging.Logger.Debugf("Deleted Service Specific Credential with ID %s of service %s from user %s", aws.StringValue(serviceSpecificCredentialId), service, aws.StringValue(userName))
+			logging.Debugf("Deleted Service Specific Credential with ID %s of service %s from user %s", aws.StringValue(serviceSpecificCredentialId), service, aws.StringValue(userName))
 		}
 	}
 
@@ -263,7 +263,7 @@ func (iu *IAMUsers) deleteMFADevices(userName *string) error {
 		UserName: userName,
 	})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] %s", err)
+		logging.Errorf("[Failed] %s", err)
 		return errors.WithStackTrace(err)
 	}
 
@@ -276,11 +276,11 @@ func (iu *IAMUsers) deleteMFADevices(userName *string) error {
 			UserName:     userName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 
-		logging.Logger.Debugf("Deactivated Virtual MFA Device with ID %s from user %s", aws.StringValue(serialNumber), aws.StringValue(userName))
+		logging.Debugf("Deactivated Virtual MFA Device with ID %s from user %s", aws.StringValue(serialNumber), aws.StringValue(userName))
 	}
 
 	// After their deactivation we can delete them
@@ -291,11 +291,11 @@ func (iu *IAMUsers) deleteMFADevices(userName *string) error {
 			SerialNumber: serialNumber,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
 
-		logging.Logger.Debugf("Deleted Virtual MFA Device with ID %s from user %s", aws.StringValue(serialNumber), aws.StringValue(userName))
+		logging.Debugf("Deleted Virtual MFA Device with ID %s from user %s", aws.StringValue(serialNumber), aws.StringValue(userName))
 	}
 
 	return nil
@@ -343,11 +343,11 @@ func (iu *IAMUsers) nukeUser(userName *string) error {
 // Delete all IAM Users
 func (iu *IAMUsers) nukeAll(userNames []*string) error {
 	if len(userNames) == 0 {
-		logging.Logger.Info("No IAM Users to nuke")
+		logging.Info("No IAM Users to nuke")
 		return nil
 	}
 
-	logging.Logger.Info("Deleting all IAM Users")
+	logging.Info("Deleting all IAM Users")
 
 	deletedUsers := 0
 	multiErr := new(multierror.Error)
@@ -363,17 +363,17 @@ func (iu *IAMUsers) nukeAll(userNames []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			multierror.Append(multiErr, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking IAM User",
 			}, map[string]interface{}{})
 		} else {
 			deletedUsers++
-			logging.Logger.Debugf("Deleted IAM User: %s", *userName)
+			logging.Debugf("Deleted IAM User: %s", *userName)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d IAM User(s) terminated", deletedUsers)
+	logging.Debugf("[OK] %d IAM User(s) terminated", deletedUsers)
 	return multiErr.ErrorOrNil()
 }
diff --git a/aws/resources/iam_group.go b/aws/resources/iam_group.go
index 72adf8d..edd6cf4 100644
--- a/aws/resources/iam_group.go
+++ b/aws/resources/iam_group.go
@@ -40,18 +40,18 @@ func (ig *IAMGroups) getAll(c context.Context, configObj config.Config) ([]*stri
 // nukeAll - delete all IAM groups.  Caller is responsible for pagination (no more than 100/request)
 func (ig *IAMGroups) nukeAll(groupNames []*string) error {
 	if len(groupNames) == 0 {
-		logging.Logger.Debug("No IAM Groups to nuke")
+		logging.Debug("No IAM Groups to nuke")
 		return nil
 	}
 
 	//Probably not required since pagination is handled by the caller
 	if len(groupNames) > 100 {
-		logging.Logger.Errorf("Nuking too many IAM Groups at once (100): Halting to avoid rate limits")
+		logging.Errorf("Nuking too many IAM Groups at once (100): Halting to avoid rate limits")
 		return TooManyIamGroupErr{}
 	}
 
 	//No bulk delete exists, do it with goroutines
-	logging.Logger.Debug("Deleting all IAM Groups")
+	logging.Debug("Deleting all IAM Groups")
 	wg := new(sync.WaitGroup)
 	wg.Add(len(groupNames))
 	errChans := make([]chan error, len(groupNames))
@@ -66,7 +66,7 @@ func (ig *IAMGroups) nukeAll(groupNames []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking IAM Group",
 			}, map[string]interface{}{})
@@ -124,7 +124,6 @@ func (ig *IAMGroups) deleteAsync(wg *sync.WaitGroup, errChan chan error, groupNa
 	allInlinePolicyNames := []*string{}
 	err = ig.Client.ListGroupPoliciesPages(&iam.ListGroupPoliciesInput{GroupName: groupName},
 		func(page *iam.ListGroupPoliciesOutput, lastPage bool) bool {
-			logging.Logger.Info("ListGroupPolicies response page: ", page)
 			for _, policyName := range page.PolicyNames {
 				allInlinePolicyNames = append(allInlinePolicyNames, policyName)
 			}
@@ -132,7 +131,6 @@ func (ig *IAMGroups) deleteAsync(wg *sync.WaitGroup, errChan chan error, groupNa
 		},
 	)
 
-	logging.Logger.Info("inline policies: ", allInlinePolicyNames)
 	for _, policyName := range allInlinePolicyNames {
 		_, err = ig.Client.DeleteGroupPolicy(&iam.DeleteGroupPolicyInput{
 			GroupName:  groupName,
@@ -147,7 +145,7 @@ func (ig *IAMGroups) deleteAsync(wg *sync.WaitGroup, errChan chan error, groupNa
 	if err != nil {
 		multierr = multierror.Append(multierr, err)
 	} else {
-		logging.Logger.Debugf("[OK] IAM Group %s was deleted in global", aws.StringValue(groupName))
+		logging.Debugf("[OK] IAM Group %s was deleted in global", aws.StringValue(groupName))
 	}
 
 	e := report.Entry{
diff --git a/aws/resources/iam_policy.go b/aws/resources/iam_policy.go
index c7ae2e1..4a6c71c 100644
--- a/aws/resources/iam_policy.go
+++ b/aws/resources/iam_policy.go
@@ -43,17 +43,17 @@ func (ip *IAMPolicies) getAll(c context.Context, configObj config.Config) ([]*st
 // Delete all iam customer managed policies. Caller is responsible for pagination (no more than 100/request)
 func (ip *IAMPolicies) nukeAll(policyArns []*string) error {
 	if len(policyArns) == 0 {
-		logging.Logger.Debug("No IAM Policies to nuke")
+		logging.Debug("No IAM Policies to nuke")
 	}
 
 	//Probably not required since pagination is handled by the caller
 	if len(policyArns) > 100 {
-		logging.Logger.Errorf("Nuking too many IAM Policies at once (100): Halting to avoid rate limits")
+		logging.Errorf("Nuking too many IAM Policies at once (100): Halting to avoid rate limits")
 		return TooManyIamPolicyErr{}
 	}
 
 	//No Bulk Delete exists, do it with goroutines
-	logging.Logger.Debug("Deleting all IAM Policies")
+	logging.Debug("Deleting all IAM Policies")
 	wg := new(sync.WaitGroup)
 	wg.Add(len(policyArns))
 	errChans := make([]chan error, len(policyArns))
@@ -68,7 +68,7 @@ func (ip *IAMPolicies) nukeAll(policyArns []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking IAM Policy",
 			}, map[string]interface{}{})
@@ -120,7 +120,7 @@ func (ip *IAMPolicies) deleteIamPolicyAsync(wg *sync.WaitGroup, errChan chan err
 	if err != nil {
 		multierr = multierror.Append(multierr, err)
 	} else {
-		logging.Logger.Debugf("[OK] IAM Policy %s was deleted in global", aws.StringValue(policyArn))
+		logging.Debugf("[OK] IAM Policy %s was deleted in global", aws.StringValue(policyArn))
 	}
 
 	e := report.Entry{
diff --git a/aws/resources/iam_role.go b/aws/resources/iam_role.go
index e9de256..ee118ee 100644
--- a/aws/resources/iam_role.go
+++ b/aws/resources/iam_role.go
@@ -51,10 +51,10 @@ func (ir *IAMRoles) deleteManagedRolePolicies(roleName *string) error {
 			RoleName:  roleName,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
-		logging.Logger.Debugf("Detached Policy %s from Role %s", aws.StringValue(arn), aws.StringValue(roleName))
+		logging.Debugf("Detached Policy %s from Role %s", aws.StringValue(arn), aws.StringValue(roleName))
 	}
 
 	return nil
@@ -65,7 +65,7 @@ func (ir *IAMRoles) deleteInlineRolePolicies(roleName *string) error {
 		RoleName: roleName,
 	})
 	if err != nil {
-		logging.Logger.Debugf("[Failed] %s", err)
+		logging.Debugf("[Failed] %s", err)
 		return errors.WithStackTrace(err)
 	}
 
@@ -75,10 +75,10 @@ func (ir *IAMRoles) deleteInlineRolePolicies(roleName *string) error {
 			RoleName:   roleName,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		}
-		logging.Logger.Debugf("Deleted Inline Policy %s from Role %s", aws.StringValue(policyName), aws.StringValue(roleName))
+		logging.Debugf("Deleted Inline Policy %s from Role %s", aws.StringValue(policyName), aws.StringValue(roleName))
 	}
 
 	return nil
@@ -100,18 +100,18 @@ func (ir *IAMRoles) deleteInstanceProfilesFromRole(roleName *string) error {
 			RoleName:            roleName,
 		})
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			return errors.WithStackTrace(err)
 		} else {
 			_, err := ir.Client.DeleteInstanceProfile(&iam.DeleteInstanceProfileInput{
 				InstanceProfileName: profile.InstanceProfileName,
 			})
 			if err != nil {
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				return errors.WithStackTrace(err)
 			}
 		}
-		logging.Logger.Debugf("Detached and Deleted InstanceProfile %s from Role %s", aws.StringValue(profile.InstanceProfileName), aws.StringValue(roleName))
+		logging.Debugf("Detached and Deleted InstanceProfile %s from Role %s", aws.StringValue(profile.InstanceProfileName), aws.StringValue(roleName))
 	}
 	return nil
 }
@@ -130,7 +130,7 @@ func (ir *IAMRoles) deleteIamRole(roleName *string) error {
 // Delete all IAM Roles
 func (ir *IAMRoles) nukeAll(roleNames []*string) error {
 	if len(roleNames) == 0 {
-		logging.Logger.Debug("No IAM Roles to nuke")
+		logging.Debug("No IAM Roles to nuke")
 		return nil
 	}
 
@@ -139,12 +139,12 @@ func (ir *IAMRoles) nukeAll(roleNames []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(roleNames) > 100 {
-		logging.Logger.Debugf("Nuking too many IAM Roles at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Debugf("Nuking too many IAM Roles at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyIamRoleErr{}
 	}
 
 	// There is no bulk delete IAM Roles API, so we delete the batch of IAM roles concurrently using go routines
-	logging.Logger.Debugf("Deleting all IAM Roles")
+	logging.Debugf("Deleting all IAM Roles")
 	wg := new(sync.WaitGroup)
 	wg.Add(len(roleNames))
 	errChans := make([]chan error, len(roleNames))
@@ -159,7 +159,7 @@ func (ir *IAMRoles) nukeAll(roleNames []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking IAM Role",
 			}, map[string]interface{}{})
@@ -171,7 +171,7 @@ func (ir *IAMRoles) nukeAll(roleNames []*string) error {
 	}
 
 	for _, roleName := range roleNames {
-		logging.Logger.Debugf("[OK] IAM Role %s was deleted", aws.StringValue(roleName))
+		logging.Debugf("[OK] IAM Role %s was deleted", aws.StringValue(roleName))
 	}
 	return nil
 }
diff --git a/aws/resources/iam_service_linked_role.go b/aws/resources/iam_service_linked_role.go
index b548609..8e37ace 100644
--- a/aws/resources/iam_service_linked_role.go
+++ b/aws/resources/iam_service_linked_role.go
@@ -67,7 +67,7 @@ func (islr *IAMServiceLinkedRoles) deleteIamServiceLinkedRole(roleName *string)
 			return gruntworkerrors.WithStackTrace(err)
 		}
 		if aws.StringValue(deletionStatus.Status) == "IN_PROGRESS" {
-			logging.Logger.Debugf("Deletion of IAM ServiceLinked Role %s is still in progress", aws.StringValue(roleName))
+			logging.Debugf("Deletion of IAM ServiceLinked Role %s is still in progress", aws.StringValue(roleName))
 			done = false
 			time.Sleep(3 * time.Second)
 		}
@@ -85,7 +85,7 @@ func (islr *IAMServiceLinkedRoles) deleteIamServiceLinkedRole(roleName *string)
 // Delete all IAM Roles
 func (islr *IAMServiceLinkedRoles) nukeAll(roleNames []*string) error {
 	if len(roleNames) == 0 {
-		logging.Logger.Debug("No IAM Service Linked Roles to nuke")
+		logging.Debug("No IAM Service Linked Roles to nuke")
 		return nil
 	}
 
@@ -94,12 +94,12 @@ func (islr *IAMServiceLinkedRoles) nukeAll(roleNames []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(roleNames) > 100 {
-		logging.Logger.Debugf("Nuking too many IAM Service Linked Roles at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Debugf("Nuking too many IAM Service Linked Roles at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyIamRoleErr{}
 	}
 
 	// There is no bulk delete IAM Roles API, so we delete the batch of IAM roles concurrently using go routines
-	logging.Logger.Debugf("Deleting all IAM Service Linked Roles")
+	logging.Debugf("Deleting all IAM Service Linked Roles")
 	wg := new(sync.WaitGroup)
 	wg.Add(len(roleNames))
 	errChans := make([]chan error, len(roleNames))
@@ -114,7 +114,7 @@ func (islr *IAMServiceLinkedRoles) nukeAll(roleNames []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking IAM Service Linked Role",
 			}, map[string]interface{}{})
@@ -126,7 +126,7 @@ func (islr *IAMServiceLinkedRoles) nukeAll(roleNames []*string) error {
 	}
 
 	for _, roleName := range roleNames {
-		logging.Logger.Debugf("[OK] IAM Service Linked Role %s was deleted.", aws.StringValue(roleName))
+		logging.Debugf("[OK] IAM Service Linked Role %s was deleted.", aws.StringValue(roleName))
 	}
 	return nil
 }
diff --git a/aws/resources/kinesis_stream.go b/aws/resources/kinesis_stream.go
index fc1d2bc..39dc6bd 100644
--- a/aws/resources/kinesis_stream.go
+++ b/aws/resources/kinesis_stream.go
@@ -39,7 +39,7 @@ func (ks *KinesisStreams) getAll(c context.Context, configObj config.Config) ([]
 
 func (ks *KinesisStreams) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No Kinesis Streams to nuke in region: %s", ks.Region)
+		logging.Debugf("No Kinesis Streams to nuke in region: %s", ks.Region)
 	}
 
 	// NOTE: we don't need to do pagination here, because the pagination is handled by the caller to this function,
@@ -47,13 +47,13 @@ func (ks *KinesisStreams) nukeAll(identifiers []*string) error {
 	// has a chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the
 	// limit here because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many Kinesis Streams at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many Kinesis Streams at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyStreamsErr{}
 	}
 
 	// There is no bulk delete Kinesis Stream API, so we delete the batch of Kinesis Streams concurrently
 	// using go routines.
-	logging.Logger.Debugf("Deleting Kinesis Streams in region: %s", ks.Region)
+	logging.Debugf("Deleting Kinesis Streams in region: %s", ks.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -107,9 +107,9 @@ func (ks *KinesisStreams) deleteAsync(
 
 	streamNameStr := aws.StringValue(streamName)
 	if err == nil {
-		logging.Logger.Debugf("[OK] Kinesis Stream %s delete in %s", streamNameStr, ks.Region)
+		logging.Debugf("[OK] Kinesis Stream %s delete in %s", streamNameStr, ks.Region)
 	} else {
-		logging.Logger.Debugf("[Failed] Error deleting Kinesis Stream %s in %s: %s", streamNameStr, ks.Region, err)
+		logging.Debugf("[Failed] Error deleting Kinesis Stream %s in %s: %s", streamNameStr, ks.Region, err)
 	}
 }
 
diff --git a/aws/resources/kms_customer_key.go b/aws/resources/kms_customer_key.go
index 333e9a6..487c278 100644
--- a/aws/resources/kms_customer_key.go
+++ b/aws/resources/kms_customer_key.go
@@ -64,7 +64,7 @@ func (kck *KmsCustomerKeys) getAll(c context.Context, configObj config.Config) (
 		resultsChan[id] = make(chan *KmsCheckIncludeResult, 1)
 
 		if err != nil {
-			logging.Logger.Debugf("Can't read KMS key %s", err.Error())
+			logging.Debugf("Can't read KMS key %s", err.Error())
 			continue
 		}
 
@@ -82,7 +82,7 @@ func (kck *KmsCustomerKeys) getAll(c context.Context, configObj config.Config) (
 	for _, channel := range resultsChan {
 		result := <-channel
 		if result.Error != nil {
-			logging.Logger.Debugf("Can't read KMS key %s", result.Error)
+			logging.Debugf("Can't read KMS key %s", result.Error)
 
 			continue
 		}
@@ -167,13 +167,13 @@ func (kck *KmsCustomerKeys) shouldInclude(
 
 func (kck *KmsCustomerKeys) nukeAll(keyIds []*string) error {
 	if len(keyIds) == 0 {
-		logging.Logger.Debugf("No Customer Keys to nuke in region %s", kck.Region)
+		logging.Debugf("No Customer Keys to nuke in region %s", kck.Region)
 		return nil
 	}
 
 	// usage of go routines for parallel keys removal
 	// https://docs.aws.amazon.com/sdk-for-go/api/service/kms/#KMS.ScheduleKeyDeletion
-	logging.Logger.Debugf("Deleting Keys secrets in region %s", kck.Region)
+	logging.Debugf("Deleting Keys secrets in region %s", kck.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(keyIds))
 	errChans := make([]chan error, len(keyIds))
@@ -195,7 +195,7 @@ func (kck *KmsCustomerKeys) nukeAll(keyIds []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking KMS Key",
 			}, map[string]interface{}{
@@ -214,9 +214,9 @@ func (kck *KmsCustomerKeys) deleteAliases(wg *sync.WaitGroup, aliases []string)
 		_, err := kck.Client.DeleteAlias(input)
 
 		if err != nil {
-			logging.Logger.Errorf("[Failed] Failed deleting alias: %s", aliasName)
+			logging.Errorf("[Failed] Failed deleting alias: %s", aliasName)
 		} else {
-			logging.Logger.Debugf("Deleted alias %s", aliasName)
+			logging.Debugf("Deleted alias %s", aliasName)
 		}
 	}
 }
diff --git a/aws/resources/lambda.go b/aws/resources/lambda.go
index 71e0950..56169fd 100644
--- a/aws/resources/lambda.go
+++ b/aws/resources/lambda.go
@@ -45,7 +45,7 @@ func (lf *LambdaFunctions) shouldInclude(lambdaFn *lambda.FunctionConfiguration,
 	layout := "2006-01-02T15:04:05.000+0000"
 	lastModifiedDateTime, err := time.Parse(layout, fnLastModified)
 	if err != nil {
-		logging.Logger.Debugf("Could not parse last modified timestamp (%s) of Lambda function %s. Excluding from delete.", fnLastModified, *fnName)
+		logging.Debugf("Could not parse last modified timestamp (%s) of Lambda function %s. Excluding from delete.", fnLastModified, *fnName)
 		return false
 	}
 
@@ -57,11 +57,11 @@ func (lf *LambdaFunctions) shouldInclude(lambdaFn *lambda.FunctionConfiguration,
 
 func (lf *LambdaFunctions) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No Lambda Functions to nuke in region %s", lf.Region)
+		logging.Debugf("No Lambda Functions to nuke in region %s", lf.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Lambda Functions in region %s", lf.Region)
+	logging.Debugf("Deleting all Lambda Functions in region %s", lf.Region)
 	deletedNames := []*string{}
 
 	for _, name := range names {
@@ -80,7 +80,7 @@ func (lf *LambdaFunctions) nukeAll(names []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s: %s", *name, err)
+			logging.Errorf("[Failed] %s: %s", *name, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Lambda Function",
 			}, map[string]interface{}{
@@ -88,10 +88,10 @@ func (lf *LambdaFunctions) nukeAll(names []*string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted Lambda Function: %s", awsgo.StringValue(name))
+			logging.Debugf("Deleted Lambda Function: %s", awsgo.StringValue(name))
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Lambda Function(s) deleted in %s", len(deletedNames), lf.Region)
+	logging.Debugf("[OK] %d Lambda Function(s) deleted in %s", len(deletedNames), lf.Region)
 	return nil
 }
diff --git a/aws/resources/launch_config.go b/aws/resources/launch_config.go
index e46b064..8278777 100644
--- a/aws/resources/launch_config.go
+++ b/aws/resources/launch_config.go
@@ -36,11 +36,11 @@ func (lc *LaunchConfigs) getAll(c context.Context, configObj config.Config) ([]*
 func (lc *LaunchConfigs) nukeAll(configNames []*string) error {
 
 	if len(configNames) == 0 {
-		logging.Logger.Debugf("No Launch Configurations to nuke in region %s", lc.Region)
+		logging.Debugf("No Launch Configurations to nuke in region %s", lc.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Launch Configurations in region %s", lc.Region)
+	logging.Debugf("Deleting all Launch Configurations in region %s", lc.Region)
 	var deletedConfigNames []*string
 
 	for _, configName := range configNames {
@@ -59,7 +59,7 @@ func (lc *LaunchConfigs) nukeAll(configNames []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Launch Configuration",
 			}, map[string]interface{}{
@@ -67,10 +67,10 @@ func (lc *LaunchConfigs) nukeAll(configNames []*string) error {
 			})
 		} else {
 			deletedConfigNames = append(deletedConfigNames, configName)
-			logging.Logger.Debugf("Deleted Launch configuration: %s", *configName)
+			logging.Debugf("Deleted Launch configuration: %s", *configName)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Launch Configuration(s) deleted in %s", len(deletedConfigNames), lc.Region)
+	logging.Debugf("[OK] %d Launch Configuration(s) deleted in %s", len(deletedConfigNames), lc.Region)
 	return nil
 }
diff --git a/aws/resources/launch_template.go b/aws/resources/launch_template.go
index 0144b1e..c23536c 100644
--- a/aws/resources/launch_template.go
+++ b/aws/resources/launch_template.go
@@ -35,11 +35,11 @@ func (lt *LaunchTemplates) getAll(c context.Context, configObj config.Config) ([
 // Deletes all Launch Templates
 func (lt *LaunchTemplates) nukeAll(templateNames []*string) error {
 	if len(templateNames) == 0 {
-		logging.Logger.Debugf("No Launch Templates to nuke in region %s", lt.Region)
+		logging.Debugf("No Launch Templates to nuke in region %s", lt.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Launch Templates in region %s", lt.Region)
+	logging.Debugf("Deleting all Launch Templates in region %s", lt.Region)
 	var deletedTemplateNames []*string
 
 	for _, templateName := range templateNames {
@@ -58,7 +58,7 @@ func (lt *LaunchTemplates) nukeAll(templateNames []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Launch Template",
 			}, map[string]interface{}{
@@ -66,10 +66,10 @@ func (lt *LaunchTemplates) nukeAll(templateNames []*string) error {
 			})
 		} else {
 			deletedTemplateNames = append(deletedTemplateNames, templateName)
-			logging.Logger.Debugf("Deleted Launch template: %s", *templateName)
+			logging.Debugf("Deleted Launch template: %s", *templateName)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Launch Template(s) deleted in %s", len(deletedTemplateNames), lt.Region)
+	logging.Debugf("[OK] %d Launch Template(s) deleted in %s", len(deletedTemplateNames), lt.Region)
 	return nil
 }
diff --git a/aws/resources/macie.go b/aws/resources/macie.go
index a6c4228..cb23570 100644
--- a/aws/resources/macie.go
+++ b/aws/resources/macie.go
@@ -64,7 +64,7 @@ func (mm *MacieMember) getAllMacieMembers() ([]*string, error) {
 			memberAccountIds = append(memberAccountIds, member.AccountId)
 		}
 	}
-	logging.Logger.Debugf("Found %d member accounts attached to macie", len(memberAccountIds))
+	logging.Debugf("Found %d member accounts attached to macie", len(memberAccountIds))
 	return memberAccountIds, nil
 }
 
@@ -76,21 +76,21 @@ func (mm *MacieMember) removeMacieMembers(memberAccountIds []*string) error {
 		if err != nil {
 			return err
 		}
-		logging.Logger.Debugf("%s member account disassociated", *accountId)
+		logging.Debugf("%s member account disassociated", *accountId)
 
 		// Once disassociated, member accounts can be deleted
 		_, err = mm.Client.DeleteMember(&macie2.DeleteMemberInput{Id: accountId})
 		if err != nil {
 			return err
 		}
-		logging.Logger.Debugf("%s member account deleted", *accountId)
+		logging.Debugf("%s member account deleted", *accountId)
 	}
 	return nil
 }
 
 func (mm *MacieMember) nukeAll(identifier []string) error {
 	if len(identifier) == 0 {
-		logging.Logger.Debugf("No Macie member accounts to nuke in region %s", mm.Region)
+		logging.Debugf("No Macie member accounts to nuke in region %s", mm.Region)
 		return nil
 	}
 
@@ -108,7 +108,7 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 	if err == nil && len(memberAccountIds) > 0 {
 		err = mm.removeMacieMembers(memberAccountIds)
 		if err != nil {
-			logging.Logger.Errorf("[Failed] Failed to remove members from macie")
+			logging.Errorf("[Failed] Failed to remove members from macie")
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error removing members from macie",
 			}, map[string]interface{}{
@@ -123,9 +123,9 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 	adminAccount, err := mm.Client.GetAdministratorAccount(&macie2.GetAdministratorAccountInput{})
 	if err != nil {
 		if strings.Contains(err.Error(), "there isn't a delegated Macie administrator") {
-			logging.Logger.Debugf("No delegated Macie administrator found to remove.")
+			logging.Debugf("No delegated Macie administrator found to remove.")
 		} else {
-			logging.Logger.Errorf("[Failed] Failed to check for administrator account")
+			logging.Errorf("[Failed] Failed to check for administrator account")
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error checking for administrator account in Macie",
 			}, map[string]interface{}{
@@ -139,7 +139,7 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 	if adminAccount.Administrator != nil {
 		_, err := mm.Client.DisassociateFromAdministratorAccount(&macie2.DisassociateFromAdministratorAccountInput{})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] Failed to disassociate from administrator account")
+			logging.Errorf("[Failed] Failed to disassociate from administrator account")
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error disassociating administrator account in Macie",
 			}, map[string]interface{}{
@@ -152,7 +152,7 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 	// Disable Macie
 	_, err = mm.Client.DisableMacie(&macie2.DisableMacieInput{})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] Failed to disable macie.")
+		logging.Errorf("[Failed] Failed to disable macie.")
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error Nuking MACIE",
 		}, map[string]interface{}{
@@ -166,7 +166,7 @@ func (mm *MacieMember) nukeAll(identifier []string) error {
 		}
 		report.Record(e)
 	} else {
-		logging.Logger.Debugf("[OK] Macie disabled in %s", mm.Region)
+		logging.Debugf("[OK] Macie disabled in %s", mm.Region)
 		e := report.Entry{
 			Identifier:   mm.Region,
 			ResourceType: "Macie",
diff --git a/aws/resources/msk_cluster.go b/aws/resources/msk_cluster.go
index 47acedf..97db1f5 100644
--- a/aws/resources/msk_cluster.go
+++ b/aws/resources/msk_cluster.go
@@ -49,7 +49,7 @@ func (m MSKCluster) nukeAll(identifiers []string) error {
 			ClusterArn: &clusterArn,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 		}
 
 		// Record status of this resource
diff --git a/aws/resources/nat_gateway.go b/aws/resources/nat_gateway.go
index 11bbefa..9ac985f 100644
--- a/aws/resources/nat_gateway.go
+++ b/aws/resources/nat_gateway.go
@@ -67,7 +67,7 @@ func getNatGatewayName(ngw *ec2.NatGateway) *string {
 
 func (ngw *NatGateways) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No Nat Gateways to nuke in region %s", ngw.Region)
+		logging.Debugf("No Nat Gateways to nuke in region %s", ngw.Region)
 		return nil
 	}
 
@@ -76,12 +76,12 @@ func (ngw *NatGateways) nukeAll(identifiers []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Debugf("Nuking too many NAT gateways at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Debugf("Nuking too many NAT gateways at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyNatErr{}
 	}
 
 	// There is no bulk delete nat gateway API, so we delete the batch of nat gateways concurrently using go routines.
-	logging.Logger.Debugf("Deleting Nat Gateways in region %s", ngw.Region)
+	logging.Debugf("Deleting Nat Gateways in region %s", ngw.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -96,7 +96,7 @@ func (ngw *NatGateways) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking NAT Gateway",
 			}, map[string]interface{}{
@@ -130,7 +130,7 @@ func (ngw *NatGateways) nukeAll(identifiers []*string) error {
 		return errors.WithStackTrace(err)
 	}
 	for _, ngwID := range identifiers {
-		logging.Logger.Debugf("[OK] NAT Gateway %s was deleted in %s", aws.StringValue(ngwID), ngw.Region)
+		logging.Debugf("[OK] NAT Gateway %s was deleted in %s", aws.StringValue(ngwID), ngw.Region)
 	}
 	return nil
 }
diff --git a/aws/resources/oidc_provider.go b/aws/resources/oidc_provider.go
index e8e3b2e..f961215 100644
--- a/aws/resources/oidc_provider.go
+++ b/aws/resources/oidc_provider.go
@@ -130,7 +130,7 @@ func (oidcprovider *OIDCProviders) getOIDCProviderDetailAsync(wg *sync.WaitGroup
 // nukeAllOIDCProviders deletes all the given OpenID Connect Providers from the account.
 func (oidcprovider *OIDCProviders) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No OIDC Providers to nuke")
+		logging.Debugf("No OIDC Providers to nuke")
 		return nil
 	}
 
@@ -139,12 +139,12 @@ func (oidcprovider *OIDCProviders) nukeAll(identifiers []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Debugf("Nuking too many OIDC Providers at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Debugf("Nuking too many OIDC Providers at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyOIDCProvidersErr{}
 	}
 
 	// There is no bulk delete OIDC Provider API, so we delete the batch of nat gateways concurrently using go routines.
-	logging.Logger.Debugf("Deleting OIDC Providers")
+	logging.Debugf("Deleting OIDC Providers")
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -159,7 +159,7 @@ func (oidcprovider *OIDCProviders) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking OIDC Provider",
 			}, map[string]interface{}{})
@@ -171,7 +171,7 @@ func (oidcprovider *OIDCProviders) nukeAll(identifiers []*string) error {
 	}
 
 	for _, providerARN := range identifiers {
-		logging.Logger.Debugf("[OK] OIDC Provider %s was deleted", aws.StringValue(providerARN))
+		logging.Debugf("[OK] OIDC Provider %s was deleted", aws.StringValue(providerARN))
 	}
 	return nil
 }
diff --git a/aws/resources/opensearch.go b/aws/resources/opensearch.go
index 7e03e86..43f9e5e 100644
--- a/aws/resources/opensearch.go
+++ b/aws/resources/opensearch.go
@@ -40,7 +40,7 @@ func (osd *OpenSearchDomains) getAll(c context.Context, configObj config.Config)
 		if firstSeenTime == nil {
 			err := osd.setFirstSeenTag(domain.ARN, time.Now().UTC())
 			if err != nil {
-				logging.Logger.Errorf("Error tagging the OpenSearch Domain with ARN %s with error: %s", aws.StringValue(domain.ARN), err.Error())
+				logging.Errorf("Error tagging the OpenSearch Domain with ARN %s with error: %s", aws.StringValue(domain.ARN), err.Error())
 				return nil, errors.WithStackTrace(err)
 			}
 		}
@@ -61,7 +61,7 @@ func (osd *OpenSearchDomains) getAllActiveOpenSearchDomains() ([]*opensearchserv
 	allDomains := []*string{}
 	resp, err := osd.Client.ListDomainNames(&opensearchservice.ListDomainNamesInput{})
 	if err != nil {
-		logging.Logger.Errorf("Error getting all OpenSearch domains")
+		logging.Errorf("Error getting all OpenSearch domains")
 		return nil, errors.WithStackTrace(err)
 	}
 	for _, domain := range resp.DomainNames {
@@ -71,7 +71,7 @@ func (osd *OpenSearchDomains) getAllActiveOpenSearchDomains() ([]*opensearchserv
 	input := &opensearchservice.DescribeDomainsInput{DomainNames: allDomains}
 	describedDomains, describeErr := osd.Client.DescribeDomains(input)
 	if describeErr != nil {
-		logging.Logger.Errorf("Error describing Domains from input %s: ", input)
+		logging.Errorf("Error describing Domains from input %s: ", input)
 		return nil, errors.WithStackTrace(describeErr)
 	}
 
@@ -86,7 +86,7 @@ func (osd *OpenSearchDomains) getAllActiveOpenSearchDomains() ([]*opensearchserv
 
 // Tag an OpenSearch Domain identified by the given ARN when it's first seen by cloud-nuke
 func (osd *OpenSearchDomains) setFirstSeenTag(domainARN *string, timestamp time.Time) error {
-	logging.Logger.Debugf("Tagging the OpenSearch Domain with ARN %s with first seen timestamp", aws.StringValue(domainARN))
+	logging.Debugf("Tagging the OpenSearch Domain with ARN %s with first seen timestamp", aws.StringValue(domainARN))
 	firstSeenTime := util.FormatTimestampTag(timestamp)
 
 	input := &opensearchservice.AddTagsInput{
@@ -114,7 +114,7 @@ func (osd *OpenSearchDomains) getFirstSeenTag(domainARN *string) (*time.Time, er
 	input := &opensearchservice.ListTagsInput{ARN: domainARN}
 	domainTags, err := osd.Client.ListTags(input)
 	if err != nil {
-		logging.Logger.Errorf("Error getting the tags for OpenSearch Domain with ARN %s", aws.StringValue(domainARN))
+		logging.Errorf("Error getting the tags for OpenSearch Domain with ARN %s", aws.StringValue(domainARN))
 		return firstSeenTime, errors.WithStackTrace(err)
 	}
 
@@ -122,7 +122,7 @@ func (osd *OpenSearchDomains) getFirstSeenTag(domainARN *string) (*time.Time, er
 		if util.IsFirstSeenTag(tag.Key) {
 			firstSeenTime, err := util.ParseTimestampTag(tag.Value)
 			if err != nil {
-				logging.Logger.Errorf("Error parsing the `cloud-nuke-first-seen` tag for OpenSearch Domain with ARN %s", aws.StringValue(domainARN))
+				logging.Errorf("Error parsing the `cloud-nuke-first-seen` tag for OpenSearch Domain with ARN %s", aws.StringValue(domainARN))
 				return firstSeenTime, errors.WithStackTrace(err)
 			}
 
@@ -138,7 +138,7 @@ func (osd *OpenSearchDomains) getFirstSeenTag(domainARN *string) (*time.Time, er
 // they can be issued concurrently.
 func (osd *OpenSearchDomains) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No OpenSearch Domains to nuke in region %s", osd.Region)
+		logging.Debugf("No OpenSearch Domains to nuke in region %s", osd.Region)
 		return nil
 	}
 
@@ -147,11 +147,11 @@ func (osd *OpenSearchDomains) nukeAll(identifiers []*string) error {
 	// chance of throttling AWS. Since we concurrently make one call for each identifier, we pick 100 for the limit here
 	// because many APIs in AWS have a limit of 100 requests per second.
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many OpenSearch Domains at once (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many OpenSearch Domains at once (100): halting to avoid hitting AWS API rate limiting")
 		return TooManyOpenSearchDomainsErr{}
 	}
 
-	logging.Logger.Debugf("Deleting OpenSearch Domains in region %s", osd.Region)
+	logging.Debugf("Deleting OpenSearch Domains in region %s", osd.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -166,7 +166,7 @@ func (osd *OpenSearchDomains) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Opensearch",
 			}, map[string]interface{}{
@@ -200,7 +200,7 @@ func (osd *OpenSearchDomains) nukeAll(identifiers []*string) error {
 		return errors.WithStackTrace(err)
 	}
 	for _, domainName := range identifiers {
-		logging.Logger.Debugf("[OK] OpenSearch Domain %s was deleted in %s", aws.StringValue(domainName), osd.Region)
+		logging.Debugf("[OK] OpenSearch Domain %s was deleted in %s", aws.StringValue(domainName), osd.Region)
 	}
 	return nil
 }
diff --git a/aws/resources/rds.go b/aws/resources/rds.go
index f6d63c0..0bbca8c 100644
--- a/aws/resources/rds.go
+++ b/aws/resources/rds.go
@@ -37,11 +37,11 @@ func (di *DBInstances) getAll(c context.Context, configObj config.Config) ([]*st
 
 func (di *DBInstances) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No RDS DB Instance to nuke in region %s", di.Region)
+		logging.Debugf("No RDS DB Instance to nuke in region %s", di.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all RDS Instances in region %s", di.Region)
+	logging.Debugf("Deleting all RDS Instances in region %s", di.Region)
 	deletedNames := []*string{}
 
 	for _, name := range names {
@@ -58,10 +58,10 @@ func (di *DBInstances) nukeAll(names []*string) error {
 			}, map[string]interface{}{
 				"region": di.Region,
 			})
-			logging.Logger.Errorf("[Failed] %s: %s", *name, err)
+			logging.Errorf("[Failed] %s: %s", *name, err)
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted RDS DB Instance: %s", awsgo.StringValue(name))
+			logging.Debugf("Deleted RDS DB Instance: %s", awsgo.StringValue(name))
 		}
 	}
 
@@ -86,12 +86,12 @@ func (di *DBInstances) nukeAll(names []*string) error {
 				}, map[string]interface{}{
 					"region": di.Region,
 				})
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				return errors.WithStackTrace(err)
 			}
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d RDS DB Instance(s) deleted in %s", len(deletedNames), di.Region)
+	logging.Debugf("[OK] %d RDS DB Instance(s) deleted in %s", len(deletedNames), di.Region)
 	return nil
 }
diff --git a/aws/resources/rds_cluster.go b/aws/resources/rds_cluster.go
index c94c9b5..259386f 100644
--- a/aws/resources/rds_cluster.go
+++ b/aws/resources/rds_cluster.go
@@ -31,7 +31,7 @@ func (instance *DBClusters) waitUntilRdsClusterDeleted(input *rds.DescribeDBClus
 		}
 
 		time.Sleep(10 * time.Second)
-		logging.Logger.Debug("Waiting for RDS Cluster to be deleted")
+		logging.Debug("Waiting for RDS Cluster to be deleted")
 	}
 
 	return RdsDeleteError{name: *input.DBClusterIdentifier}
@@ -59,11 +59,11 @@ func (instance *DBClusters) getAll(c context.Context, configObj config.Config) (
 
 func (instance *DBClusters) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No RDS DB Cluster to nuke in region %s", instance.Region)
+		logging.Debugf("No RDS DB Cluster to nuke in region %s", instance.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all RDS Clusters in region %s", instance.Region)
+	logging.Debugf("Deleting all RDS Clusters in region %s", instance.Region)
 	deletedNames := []*string{}
 
 	for _, name := range names {
@@ -83,7 +83,7 @@ func (instance *DBClusters) nukeAll(names []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s: %s", *name, err)
+			logging.Debugf("[Failed] %s: %s", *name, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking RDS Cluster",
 			}, map[string]interface{}{
@@ -91,7 +91,7 @@ func (instance *DBClusters) nukeAll(names []*string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted RDS DB Cluster: %s", awsgo.StringValue(name))
+			logging.Debugf("Deleted RDS DB Cluster: %s", awsgo.StringValue(name))
 		}
 	}
 
@@ -102,12 +102,12 @@ func (instance *DBClusters) nukeAll(names []*string) error {
 				DBClusterIdentifier: name,
 			})
 			if err != nil {
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				return errors.WithStackTrace(err)
 			}
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d RDS DB Cluster(s) nuked in %s", len(deletedNames), instance.Region)
+	logging.Debugf("[OK] %d RDS DB Cluster(s) nuked in %s", len(deletedNames), instance.Region)
 	return nil
 }
diff --git a/aws/resources/rds_subnet_group.go b/aws/resources/rds_subnet_group.go
index 0427331..cbdf569 100644
--- a/aws/resources/rds_subnet_group.go
+++ b/aws/resources/rds_subnet_group.go
@@ -29,7 +29,7 @@ func (dsg *DBSubnetGroups) waitUntilRdsDbSubnetGroupDeleted(name *string) error
 		}
 
 		time.Sleep(10 * time.Second)
-		logging.Logger.Debug("Waiting for RDS Cluster to be deleted")
+		logging.Debug("Waiting for RDS Cluster to be deleted")
 	}
 
 	return RdsDeleteError{name: *name}
@@ -59,11 +59,11 @@ func (dsg *DBSubnetGroups) getAll(c context.Context, configObj config.Config) ([
 
 func (dsg *DBSubnetGroups) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No DB Subnet groups in region %s", dsg.Region)
+		logging.Debugf("No DB Subnet groups in region %s", dsg.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all DB Subnet groups in region %s", dsg.Region)
+	logging.Debugf("Deleting all DB Subnet groups in region %s", dsg.Region)
 	deletedNames := []*string{}
 
 	for _, name := range names {
@@ -80,7 +80,7 @@ func (dsg *DBSubnetGroups) nukeAll(names []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s: %s", *name, err)
+			logging.Debugf("[Failed] %s: %s", *name, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking RDS DB subnet group",
 			}, map[string]interface{}{
@@ -88,7 +88,7 @@ func (dsg *DBSubnetGroups) nukeAll(names []*string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted RDS DB subnet group: %s", awsgo.StringValue(name))
+			logging.Debugf("Deleted RDS DB subnet group: %s", awsgo.StringValue(name))
 		}
 	}
 
@@ -97,12 +97,12 @@ func (dsg *DBSubnetGroups) nukeAll(names []*string) error {
 
 			err := dsg.waitUntilRdsDbSubnetGroupDeleted(name)
 			if err != nil {
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				return errors.WithStackTrace(err)
 			}
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d RDS DB subnet group(s) nuked in %s", len(deletedNames), dsg.Region)
+	logging.Debugf("[OK] %d RDS DB subnet group(s) nuked in %s", len(deletedNames), dsg.Region)
 	return nil
 }
diff --git a/aws/resources/redshift.go b/aws/resources/redshift.go
index 6103794..344acff 100644
--- a/aws/resources/redshift.go
+++ b/aws/resources/redshift.go
@@ -35,10 +35,10 @@ func (rc *RedshiftClusters) getAll(c context.Context, configObj config.Config) (
 
 func (rc *RedshiftClusters) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No Redshift Clusters to nuke in region %s", rc.Region)
+		logging.Debugf("No Redshift Clusters to nuke in region %s", rc.Region)
 		return nil
 	}
-	logging.Logger.Debugf("Deleting all Redshift Clusters in region %s", rc.Region)
+	logging.Debugf("Deleting all Redshift Clusters in region %s", rc.Region)
 	deletedIds := []*string{}
 	for _, id := range identifiers {
 		_, err := rc.Client.DeleteCluster(&redshift.DeleteClusterInput{
@@ -51,10 +51,10 @@ func (rc *RedshiftClusters) nukeAll(identifiers []*string) error {
 			}, map[string]interface{}{
 				"region": rc.Region,
 			})
-			logging.Logger.Errorf("[Failed] %s: %s", *id, err)
+			logging.Errorf("[Failed] %s: %s", *id, err)
 		} else {
 			deletedIds = append(deletedIds, id)
-			logging.Logger.Debugf("Deleted Redshift Cluster: %s", aws.StringValue(id))
+			logging.Debugf("Deleted Redshift Cluster: %s", aws.StringValue(id))
 		}
 	}
 
@@ -74,11 +74,11 @@ func (rc *RedshiftClusters) nukeAll(identifiers []*string) error {
 				}, map[string]interface{}{
 					"region": rc.Region,
 				})
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				return errors.WithStackTrace(err)
 			}
 		}
 	}
-	logging.Logger.Debugf("[OK] %d Redshift Cluster(s) deleted in %s", len(deletedIds), rc.Region)
+	logging.Debugf("[OK] %d Redshift Cluster(s) deleted in %s", len(deletedIds), rc.Region)
 	return nil
 }
diff --git a/aws/resources/s3.go b/aws/resources/s3.go
index d98dd53..29be1eb 100644
--- a/aws/resources/s3.go
+++ b/aws/resources/s3.go
@@ -96,7 +96,7 @@ func (sb S3Buckets) getAll(c context.Context, configObj config.Config) ([]*strin
 	// Batch the get operation
 	for batchStart := 0; batchStart < totalBuckets; batchStart += batchSize {
 		batchEnd := int(math.Min(float64(batchStart)+float64(batchSize), float64(totalBuckets)))
-		logging.Logger.Debugf("Getting - %d-%d buckets of batch %d/%d", batchStart+1, batchEnd, batchCount, totalBatches)
+		logging.Debugf("Getting - %d-%d buckets of batch %d/%d", batchStart+1, batchEnd, batchCount, totalBatches)
 		targetBuckets := output.Buckets[batchStart:batchEnd]
 		bucketNames, err := sb.getBucketNames(targetBuckets, configObj)
 		if err != nil {
@@ -133,11 +133,11 @@ func (sb S3Buckets) getBucketNames(targetBuckets []*s3.Bucket, configObj config.
 	// messages are shown to the user as soon as possible
 	for bucketData := range bucketCh {
 		if bucketData.Error != nil {
-			logging.Logger.Debugf("Skipping - Bucket %s - region - %s - error: %s", bucketData.Name, sb.Region, bucketData.Error)
+			logging.Debugf("Skipping - Bucket %s - region - %s - error: %s", bucketData.Name, sb.Region, bucketData.Error)
 			continue
 		}
 		if !bucketData.IsValid {
-			logging.Logger.Debugf("Skipping - Bucket %s - region - %s - %s", bucketData.Name, sb.Region, bucketData.InvalidReason)
+			logging.Debugf("Skipping - Bucket %s - region - %s - %s", bucketData.Name, sb.Region, bucketData.InvalidReason)
 			continue
 		}
 
@@ -210,21 +210,21 @@ func (sb S3Buckets) emptyBucket(bucketName *string, isVersioned bool) error {
 				MaxKeys: aws.Int64(int64(sb.MaxBatchSize())),
 			},
 			func(page *s3.ListObjectVersionsOutput, lastPage bool) (shouldContinue bool) {
-				logging.Logger.Debugf("Deleting page %d of object versions (%d objects) from bucket %s", pageId, len(page.Versions), aws.StringValue(bucketName))
+				logging.Debugf("Deleting page %d of object versions (%d objects) from bucket %s", pageId, len(page.Versions), aws.StringValue(bucketName))
 				if err := sb.deleteObjectVersions(bucketName, page.Versions); err != nil {
-					logging.Logger.Errorf("Error deleting objects versions for page %d from bucket %s: %s", pageId, aws.StringValue(bucketName), err)
+					logging.Errorf("Error deleting objects versions for page %d from bucket %s: %s", pageId, aws.StringValue(bucketName), err)
 					errOut = err
 					return false
 				}
-				logging.Logger.Debugf("[OK] - deleted page %d of object versions (%d objects) from bucket %s", pageId, len(page.Versions), aws.StringValue(bucketName))
+				logging.Debugf("[OK] - deleted page %d of object versions (%d objects) from bucket %s", pageId, len(page.Versions), aws.StringValue(bucketName))
 
-				logging.Logger.Debugf("Deleting page %d of deletion markers (%d deletion markers) from bucket %s", pageId, len(page.DeleteMarkers), aws.StringValue(bucketName))
+				logging.Debugf("Deleting page %d of deletion markers (%d deletion markers) from bucket %s", pageId, len(page.DeleteMarkers), aws.StringValue(bucketName))
 				if err := sb.deleteDeletionMarkers(bucketName, page.DeleteMarkers); err != nil {
-					logging.Logger.Debugf("Error deleting deletion markers for page %d from bucket %s: %s", pageId, aws.StringValue(bucketName), err)
+					logging.Debugf("Error deleting deletion markers for page %d from bucket %s: %s", pageId, aws.StringValue(bucketName), err)
 					errOut = err
 					return false
 				}
-				logging.Logger.Debugf("[OK] - deleted page %d of deletion markers (%d deletion markers) from bucket %s", pageId, len(page.DeleteMarkers), aws.StringValue(bucketName))
+				logging.Debugf("[OK] - deleted page %d of deletion markers (%d deletion markers) from bucket %s", pageId, len(page.DeleteMarkers), aws.StringValue(bucketName))
 
 				pageId++
 				return true
@@ -246,13 +246,13 @@ func (sb S3Buckets) emptyBucket(bucketName *string, isVersioned bool) error {
 			MaxKeys: aws.Int64(int64(sb.MaxBatchSize())),
 		},
 		func(page *s3.ListObjectsV2Output, lastPage bool) (shouldContinue bool) {
-			logging.Logger.Debugf("Deleting object page %d (%d objects) from bucket %s", pageId, len(page.Contents), aws.StringValue(bucketName))
+			logging.Debugf("Deleting object page %d (%d objects) from bucket %s", pageId, len(page.Contents), aws.StringValue(bucketName))
 			if err := sb.deleteObjects(bucketName, page.Contents); err != nil {
-				logging.Logger.Errorf("Error deleting objects for page %d from bucket %s: %s", pageId, aws.StringValue(bucketName), err)
+				logging.Errorf("Error deleting objects for page %d from bucket %s: %s", pageId, aws.StringValue(bucketName), err)
 				errOut = err
 				return false
 			}
-			logging.Logger.Debugf("[OK] - deleted object page %d (%d objects) from bucket %s", pageId, len(page.Contents), aws.StringValue(bucketName))
+			logging.Debugf("[OK] - deleted object page %d (%d objects) from bucket %s", pageId, len(page.Contents), aws.StringValue(bucketName))
 
 			pageId++
 			return true
@@ -270,7 +270,7 @@ func (sb S3Buckets) emptyBucket(bucketName *string, isVersioned bool) error {
 // deleteObjects will delete the provided objects (unversioned) from the specified bucket.
 func (sb S3Buckets) deleteObjects(bucketName *string, objects []*s3.Object) error {
 	if len(objects) == 0 {
-		logging.Logger.Debugf("No objects returned in page")
+		logging.Debugf("No objects returned in page")
 		return nil
 	}
 
@@ -295,7 +295,7 @@ func (sb S3Buckets) deleteObjects(bucketName *string, objects []*s3.Object) erro
 // deleteObjectVersions will delete the provided object versions from the specified bucket.
 func (sb S3Buckets) deleteObjectVersions(bucketName *string, objectVersions []*s3.ObjectVersion) error {
 	if len(objectVersions) == 0 {
-		logging.Logger.Debugf("No object versions returned in page")
+		logging.Debugf("No object versions returned in page")
 		return nil
 	}
 
@@ -321,7 +321,7 @@ func (sb S3Buckets) deleteObjectVersions(bucketName *string, objectVersions []*s
 // deleteDeletionMarkers will delete the provided deletion markers from the specified bucket.
 func (sb S3Buckets) deleteDeletionMarkers(bucketName *string, objectDelMarkers []*s3.DeleteMarkerEntry) error {
 	if len(objectDelMarkers) == 0 {
-		logging.Logger.Debugf("No deletion markers returned in page")
+		logging.Debugf("No deletion markers returned in page")
 		return nil
 	}
 
@@ -359,11 +359,11 @@ func (sb S3Buckets) nukeAllS3BucketObjects(bucketName *string) error {
 		return fmt.Errorf("Invalid batchsize - %d - should be between %d and %d", sb.MaxBatchSize(), 1, 1000)
 	}
 
-	logging.Logger.Debugf("Emptying bucket %s", aws.StringValue(bucketName))
+	logging.Debugf("Emptying bucket %s", aws.StringValue(bucketName))
 	if err := sb.emptyBucket(bucketName, isVersioned); err != nil {
 		return err
 	}
-	logging.Logger.Debugf("[OK] - successfully emptied bucket %s", aws.StringValue(bucketName))
+	logging.Debugf("[OK] - successfully emptied bucket %s", aws.StringValue(bucketName))
 	return nil
 }
 
@@ -384,17 +384,17 @@ func (sb S3Buckets) nukeEmptyS3Bucket(bucketName *string, verifyBucketDeletion b
 	// such, we retry this routine up to 3 times for a total of 300 seconds.
 	const maxRetries = 3
 	for i := 0; i < maxRetries; i++ {
-		logging.Logger.Debugf("Waiting until bucket (%s) deletion is propagated (attempt %d / %d)", aws.StringValue(bucketName), i+1, maxRetries)
+		logging.Debugf("Waiting until bucket (%s) deletion is propagated (attempt %d / %d)", aws.StringValue(bucketName), i+1, maxRetries)
 		err = sb.Client.WaitUntilBucketNotExists(&s3.HeadBucketInput{
 			Bucket: bucketName,
 		})
 		// Exit early if no error
 		if err == nil {
-			logging.Logger.Debug("Successfully detected bucket deletion.")
+			logging.Debug("Successfully detected bucket deletion.")
 			return nil
 		}
-		logging.Logger.Debugf("Error waiting for bucket (%s) deletion propagation (attempt %d / %d)", aws.StringValue(bucketName), i+1, maxRetries)
-		logging.Logger.Debugf("Underlying error was: %s", err)
+		logging.Debugf("Error waiting for bucket (%s) deletion propagation (attempt %d / %d)", aws.StringValue(bucketName), i+1, maxRetries)
+		logging.Debugf("Underlying error was: %s", err)
 	}
 	return err
 }
@@ -411,23 +411,23 @@ func (sb S3Buckets) nukeAll(bucketNames []*string) (delCount int, err error) {
 	verifyBucketDeletion := true
 
 	if len(bucketNames) == 0 {
-		logging.Logger.Debugf("No S3 Buckets to nuke in region %s", sb.Region)
+		logging.Debugf("No S3 Buckets to nuke in region %s", sb.Region)
 		return 0, nil
 	}
 
 	totalCount := len(bucketNames)
 
-	logging.Logger.Debugf("Deleting - %d S3 Buckets in region %s", totalCount, sb.Region)
+	logging.Debugf("Deleting - %d S3 Buckets in region %s", totalCount, sb.Region)
 
 	multiErr := new(multierror.Error)
 	for bucketIndex := 0; bucketIndex < totalCount; bucketIndex++ {
 
 		bucketName := bucketNames[bucketIndex]
-		logging.Logger.Debugf("Deleting - %d/%d - Bucket: %s", bucketIndex+1, totalCount, *bucketName)
+		logging.Debugf("Deleting - %d/%d - Bucket: %s", bucketIndex+1, totalCount, *bucketName)
 
 		err = sb.nukeAllS3BucketObjects(bucketName)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] - %d/%d - Bucket: %s - object deletion error - %s", bucketIndex+1, totalCount, *bucketName, err)
+			logging.Debugf("[Failed] - %d/%d - Bucket: %s - object deletion error - %s", bucketIndex+1, totalCount, *bucketName, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking S3 Bucket Objects",
 			}, map[string]interface{}{
@@ -439,7 +439,7 @@ func (sb S3Buckets) nukeAll(bucketNames []*string) (delCount int, err error) {
 
 		err = sb.nukeS3BucketPolicy(bucketName)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] - %d/%d - Bucket: %s - bucket policy cleanup error - %s", bucketIndex+1, totalCount, *bucketName, err)
+			logging.Debugf("[Failed] - %d/%d - Bucket: %s - bucket policy cleanup error - %s", bucketIndex+1, totalCount, *bucketName, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking S3 Bucket Polikcy",
 			}, map[string]interface{}{
@@ -451,7 +451,7 @@ func (sb S3Buckets) nukeAll(bucketNames []*string) (delCount int, err error) {
 
 		err = sb.nukeEmptyS3Bucket(bucketName, verifyBucketDeletion)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] - %d/%d - Bucket: %s - bucket deletion error - %s", bucketIndex+1, totalCount, *bucketName, err)
+			logging.Debugf("[Failed] - %d/%d - Bucket: %s - bucket deletion error - %s", bucketIndex+1, totalCount, *bucketName, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking S3 Bucket",
 			}, map[string]interface{}{
@@ -469,7 +469,7 @@ func (sb S3Buckets) nukeAll(bucketNames []*string) (delCount int, err error) {
 		}
 		report.Record(e)
 
-		logging.Logger.Debugf("[OK] - %d/%d - Bucket: %s - deleted", bucketIndex+1, totalCount, *bucketName)
+		logging.Debugf("[OK] - %d/%d - Bucket: %s - deleted", bucketIndex+1, totalCount, *bucketName)
 		delCount++
 	}
 
diff --git a/aws/resources/s3_types.go b/aws/resources/s3_types.go
index af17818..3e7a469 100644
--- a/aws/resources/s3_types.go
+++ b/aws/resources/s3_types.go
@@ -66,10 +66,10 @@ func (bucket *S3Buckets) Nuke(identifiers []string) error {
 
 	totalCount := len(identifiers)
 	if delCount > 0 {
-		logging.Logger.Debugf("[OK] - %d/%d - S3 bucket(s) deleted in %s", delCount, totalCount, bucket.Region)
+		logging.Debugf("[OK] - %d/%d - S3 bucket(s) deleted in %s", delCount, totalCount, bucket.Region)
 	}
 	if delCount != totalCount {
-		logging.Logger.Debugf("[Failed] - %d/%d - S3 bucket(s) failed deletion in %s", totalCount-delCount, totalCount, bucket.Region)
+		logging.Debugf("[Failed] - %d/%d - S3 bucket(s) failed deletion in %s", totalCount-delCount, totalCount, bucket.Region)
 	}
 
 	if err != nil {
diff --git a/aws/resources/sagemaker_notebook_instance.go b/aws/resources/sagemaker_notebook_instance.go
index bc781ef..de8c4b9 100644
--- a/aws/resources/sagemaker_notebook_instance.go
+++ b/aws/resources/sagemaker_notebook_instance.go
@@ -35,11 +35,11 @@ func (smni *SageMakerNotebookInstances) getAll(c context.Context, configObj conf
 
 func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 	if len(names) == 0 {
-		logging.Logger.Debugf("No Sagemaker Notebook Instance to nuke in region %s", smni.Region)
+		logging.Debugf("No Sagemaker Notebook Instance to nuke in region %s", smni.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Sagemaker Notebook Instances in region %s", smni.Region)
+	logging.Debugf("Deleting all Sagemaker Notebook Instances in region %s", smni.Region)
 	deletedNames := []*string{}
 
 	for _, name := range names {
@@ -47,7 +47,7 @@ func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 			NotebookInstanceName: name,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s: %s", *name, err)
+			logging.Errorf("[Failed] %s: %s", *name, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Sagemaker Notebook Instance",
 			}, map[string]interface{}{
@@ -60,7 +60,7 @@ func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 			NotebookInstanceName: name,
 		})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Sagemaker Notebook Instance",
 			}, map[string]interface{}{
@@ -74,7 +74,7 @@ func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 		})
 
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s: %s", *name, err)
+			logging.Errorf("[Failed] %s: %s", *name, err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Sagemaker Notebook Instance",
 			}, map[string]interface{}{
@@ -83,7 +83,7 @@ func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 			})
 		} else {
 			deletedNames = append(deletedNames, name)
-			logging.Logger.Debugf("Deleted Sagemaker Notebook Instance: %s", awsgo.StringValue(name))
+			logging.Debugf("Deleted Sagemaker Notebook Instance: %s", awsgo.StringValue(name))
 		}
 	}
 
@@ -103,7 +103,7 @@ func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 			report.Record(e)
 
 			if err != nil {
-				logging.Logger.Errorf("[Failed] %s", err)
+				logging.Errorf("[Failed] %s", err)
 				telemetry.TrackEvent(commonTelemetry.EventContext{
 					EventName: "Error Nuking Sagemaker Notebook Instance",
 				}, map[string]interface{}{
@@ -115,6 +115,6 @@ func (smni *SageMakerNotebookInstances) nukeAll(names []*string) error {
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Sagemaker Notebook Instance(s) deleted in %s", len(deletedNames), smni.Region)
+	logging.Debugf("[OK] %d Sagemaker Notebook Instance(s) deleted in %s", len(deletedNames), smni.Region)
 	return nil
 }
diff --git a/aws/resources/secrets_manager.go b/aws/resources/secrets_manager.go
index 946e48e..ae2d937 100644
--- a/aws/resources/secrets_manager.go
+++ b/aws/resources/secrets_manager.go
@@ -56,12 +56,12 @@ func shouldIncludeSecret(secret *secretsmanager.SecretListEntry, configObj confi
 
 func (sms *SecretsManagerSecrets) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No Secrets Manager Secrets to nuke in region %s", sms.Region)
+		logging.Debugf("No Secrets Manager Secrets to nuke in region %s", sms.Region)
 		return nil
 	}
 
 	// There is no bulk delete secrets API, so we delete the batch of secrets concurrently using go routines.
-	logging.Logger.Debugf("Deleting Secrets Manager secrets in region %s", sms.Region)
+	logging.Debugf("Deleting Secrets Manager secrets in region %s", sms.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -76,7 +76,7 @@ func (sms *SecretsManagerSecrets) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Secrets Manager Secret",
 			}, map[string]interface{}{
diff --git a/aws/resources/security_hub.go b/aws/resources/security_hub.go
index f09201d..aabec8e 100644
--- a/aws/resources/security_hub.go
+++ b/aws/resources/security_hub.go
@@ -41,7 +41,7 @@ func (sh *SecurityHub) getAll(c context.Context, configObj config.Config) ([]*st
 func shouldIncludeHub(hub *securityhub.DescribeHubOutput, configObj config.Config) bool {
 	subscribedAt, err := time.Parse(time.RFC3339, *hub.SubscribedAt)
 	if err != nil {
-		logging.Logger.Debugf(
+		logging.Debugf(
 			"Could not parse subscribedAt timestamp (%s) of security hub. Excluding from delete.", *hub.SubscribedAt)
 		return false
 	}
@@ -70,7 +70,7 @@ func (sh *SecurityHub) getAllSecurityHubMembers() ([]*string, error) {
 			hubMemberAccountIds = append(hubMemberAccountIds, member.AccountId)
 		}
 	}
-	logging.Logger.Debugf("Found %d member accounts attached to security hub", len(hubMemberAccountIds))
+	logging.Debugf("Found %d member accounts attached to security hub", len(hubMemberAccountIds))
 	return hubMemberAccountIds, nil
 }
 
@@ -81,21 +81,21 @@ func (sh *SecurityHub) removeMembersFromHub(accountIds []*string) error {
 	if err != nil {
 		return err
 	}
-	logging.Logger.Debugf("%d member accounts disassociated", len(accountIds))
+	logging.Debugf("%d member accounts disassociated", len(accountIds))
 
 	// Once disassociated, member accounts can be deleted
 	_, err = sh.Client.DeleteMembers(&securityhub.DeleteMembersInput{AccountIds: accountIds})
 	if err != nil {
 		return err
 	}
-	logging.Logger.Debugf("%d member accounts deleted", len(accountIds))
+	logging.Debugf("%d member accounts deleted", len(accountIds))
 
 	return nil
 }
 
 func (sh *SecurityHub) nukeAll(securityHubArns []string) error {
 	if len(securityHubArns) == 0 {
-		logging.Logger.Debugf("No security hub resources to nuke in region %s", sh.Region)
+		logging.Debugf("No security hub resources to nuke in region %s", sh.Region)
 		return nil
 	}
 
@@ -115,7 +115,7 @@ func (sh *SecurityHub) nukeAll(securityHubArns []string) error {
 	if err == nil && len(memberAccountIds) > 0 {
 		err = sh.removeMembersFromHub(memberAccountIds)
 		if err != nil {
-			logging.Logger.Errorf("[Failed] Failed to disassociate members from security hub")
+			logging.Errorf("[Failed] Failed to disassociate members from security hub")
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error disassociating members from security hub",
 			}, map[string]interface{}{
@@ -129,7 +129,7 @@ func (sh *SecurityHub) nukeAll(securityHubArns []string) error {
 	// Security hub cannot be disabled with an active administrator account
 	adminAccount, err := sh.Client.GetAdministratorAccount(&securityhub.GetAdministratorAccountInput{})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] Failed to check for administrator account")
+		logging.Errorf("[Failed] Failed to check for administrator account")
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error checking for administrator account in security hub",
 		}, map[string]interface{}{
@@ -142,7 +142,7 @@ func (sh *SecurityHub) nukeAll(securityHubArns []string) error {
 	if adminAccount.Administrator != nil {
 		_, err := sh.Client.DisassociateFromAdministratorAccount(&securityhub.DisassociateFromAdministratorAccountInput{})
 		if err != nil {
-			logging.Logger.Errorf("[Failed] Failed to disassociate from administrator account")
+			logging.Errorf("[Failed] Failed to disassociate from administrator account")
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error disassociating administrator account in security hub",
 			}, map[string]interface{}{
@@ -155,7 +155,7 @@ func (sh *SecurityHub) nukeAll(securityHubArns []string) error {
 	// Disable security hub
 	_, err = sh.Client.DisableSecurityHub(&securityhub.DisableSecurityHubInput{})
 	if err != nil {
-		logging.Logger.Errorf("[Failed] Failed to disable security hub.")
+		logging.Errorf("[Failed] Failed to disable security hub.")
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Error disabling security hub",
 		}, map[string]interface{}{
@@ -169,7 +169,7 @@ func (sh *SecurityHub) nukeAll(securityHubArns []string) error {
 		}
 		report.Record(e)
 	} else {
-		logging.Logger.Debugf("[OK] Security Hub %s disabled", securityHubArns[0])
+		logging.Debugf("[OK] Security Hub %s disabled", securityHubArns[0])
 		e := report.Entry{
 			Identifier:   aws.StringValue(&securityHubArns[0]),
 			ResourceType: "Security Hub",
diff --git a/aws/resources/snapshot.go b/aws/resources/snapshot.go
index 6abd61d..10c2d65 100644
--- a/aws/resources/snapshot.go
+++ b/aws/resources/snapshot.go
@@ -66,11 +66,11 @@ func SnapshotHasAWSBackupTag(tags []*ec2.Tag) bool {
 func (s *Snapshots) nukeAll(snapshotIds []*string) error {
 
 	if len(snapshotIds) == 0 {
-		logging.Logger.Debugf("No Snapshots to nuke in region %s", s.Region)
+		logging.Debugf("No Snapshots to nuke in region %s", s.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Snapshots in region %s", s.Region)
+	logging.Debugf("Deleting all Snapshots in region %s", s.Region)
 	var deletedSnapshotIDs []*string
 
 	for _, snapshotID := range snapshotIds {
@@ -89,7 +89,7 @@ func (s *Snapshots) nukeAll(snapshotIds []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking EBS Snapshot",
 			}, map[string]interface{}{
@@ -97,10 +97,10 @@ func (s *Snapshots) nukeAll(snapshotIds []*string) error {
 			})
 		} else {
 			deletedSnapshotIDs = append(deletedSnapshotIDs, snapshotID)
-			logging.Logger.Debugf("Deleted Snapshot: %s", *snapshotID)
+			logging.Debugf("Deleted Snapshot: %s", *snapshotID)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Snapshot(s) terminated in %s", len(deletedSnapshotIDs), s.Region)
+	logging.Debugf("[OK] %d Snapshot(s) terminated in %s", len(deletedSnapshotIDs), s.Region)
 	return nil
 }
diff --git a/aws/resources/sns.go b/aws/resources/sns.go
index d23df3d..28a3d1f 100644
--- a/aws/resources/sns.go
+++ b/aws/resources/sns.go
@@ -28,7 +28,7 @@ func (s *SNSTopic) getAll(c context.Context, configObj config.Config) ([]*string
 		for _, topic := range page.Topics {
 			firstSeenTime, err := s.getFirstSeenSNSTopicTag(*topic.TopicArn)
 			if err != nil {
-				logging.Logger.Errorf(
+				logging.Errorf(
 					"Unable to retrieve tags for SNS Topic: %s, with error: %s", *topic.TopicArn, err)
 				continue
 			}
@@ -37,7 +37,7 @@ func (s *SNSTopic) getAll(c context.Context, configObj config.Config) ([]*string
 				now := time.Now().UTC()
 				firstSeenTime = &now
 				if err := s.setFirstSeenSNSTopicTag(*topic.TopicArn, now); err != nil {
-					logging.Logger.Errorf(
+					logging.Errorf(
 						"Unable to apply first seen tag SNS Topic: %s, with error: %s", *topic.TopicArn, err)
 					continue
 				}
@@ -127,16 +127,16 @@ func shouldIncludeSNS(topicArn string, excludeAfter, firstSeenTime time.Time, co
 
 func (s *SNSTopic) nukeAll(identifiers []*string) error {
 	if len(identifiers) == 0 {
-		logging.Logger.Debugf("No SNS Topics to nuke in region %s", s.Region)
+		logging.Debugf("No SNS Topics to nuke in region %s", s.Region)
 	}
 
 	if len(identifiers) > 100 {
-		logging.Logger.Errorf("Nuking too many SNS Topics (100): halting to avoid hitting AWS API rate limiting")
+		logging.Errorf("Nuking too many SNS Topics (100): halting to avoid hitting AWS API rate limiting")
 		return TooManySNSTopicsErr{}
 	}
 
 	// There is no bulk delete SNS API, so we delete the batch of SNS Topics concurrently using goroutines
-	logging.Logger.Debugf("Deleting SNS Topics in region %s", s.Region)
+	logging.Debugf("Deleting SNS Topics in region %s", s.Region)
 	wg := new(sync.WaitGroup)
 	wg.Add(len(identifiers))
 	errChans := make([]chan error, len(identifiers))
@@ -150,7 +150,7 @@ func (s *SNSTopic) nukeAll(identifiers []*string) error {
 	for _, errChan := range errChans {
 		if err := <-errChan; err != nil {
 			allErrs = multierror.Append(allErrs, err)
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking SNS Topic",
 			}, map[string]interface{}{
@@ -172,7 +172,7 @@ func (s *SNSTopic) deleteAsync(wg *sync.WaitGroup, errChan chan error, topicArn
 		TopicArn: topicArn,
 	}
 
-	logging.Logger.Debugf("Deleting SNS Topic (arn=%s) in region: %s", aws.StringValue(topicArn), s.Region)
+	logging.Debugf("Deleting SNS Topic (arn=%s) in region: %s", aws.StringValue(topicArn), s.Region)
 
 	_, err := s.Client.DeleteTopic(deleteParam)
 
@@ -187,8 +187,8 @@ func (s *SNSTopic) deleteAsync(wg *sync.WaitGroup, errChan chan error, topicArn
 	report.Record(e)
 
 	if err == nil {
-		logging.Logger.Debugf("[OK] Deleted SNS Topic (arn=%s) in region: %s", aws.StringValue(topicArn), s.Region)
+		logging.Debugf("[OK] Deleted SNS Topic (arn=%s) in region: %s", aws.StringValue(topicArn), s.Region)
 	} else {
-		logging.Logger.Debugf("[Failed] Error deleting SNS Topic (arn=%s) in %s", aws.StringValue(topicArn), s.Region)
+		logging.Debugf("[Failed] Error deleting SNS Topic (arn=%s) in %s", aws.StringValue(topicArn), s.Region)
 	}
 }
diff --git a/aws/resources/sqs.go b/aws/resources/sqs.go
index 9c8c376..a18a306 100644
--- a/aws/resources/sqs.go
+++ b/aws/resources/sqs.go
@@ -65,11 +65,11 @@ func (sq *SqsQueue) getAll(c context.Context, configObj config.Config) ([]*strin
 // Deletes all Elastic Load Balancers
 func (sq *SqsQueue) nukeAll(urls []*string) error {
 	if len(urls) == 0 {
-		logging.Logger.Debugf("No SQS Queues to nuke in region %s", sq.Region)
+		logging.Debugf("No SQS Queues to nuke in region %s", sq.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all SQS Queues in region %s", sq.Region)
+	logging.Debugf("Deleting all SQS Queues in region %s", sq.Region)
 	var deletedUrls []*string
 
 	for _, url := range urls {
@@ -88,7 +88,7 @@ func (sq *SqsQueue) nukeAll(urls []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking SQS Queue",
 			}, map[string]interface{}{
@@ -96,11 +96,11 @@ func (sq *SqsQueue) nukeAll(urls []*string) error {
 			})
 		} else {
 			deletedUrls = append(deletedUrls, url)
-			logging.Logger.Debugf("Deleted SQS Queue: %s", *url)
+			logging.Debugf("Deleted SQS Queue: %s", *url)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d SQS Queue(s) deleted in %s", len(deletedUrls), sq.Region)
+	logging.Debugf("[OK] %d SQS Queue(s) deleted in %s", len(deletedUrls), sq.Region)
 
 	return nil
 }
diff --git a/aws/resources/transit_gateway.go b/aws/resources/transit_gateway.go
index 84b75d3..e7943af 100644
--- a/aws/resources/transit_gateway.go
+++ b/aws/resources/transit_gateway.go
@@ -34,11 +34,11 @@ func (tgw *TransitGateways) getAll(c context.Context, configObj config.Config) (
 // Delete all TransitGateways
 func (tgw *TransitGateways) nukeAll(ids []*string) error {
 	if len(ids) == 0 {
-		logging.Logger.Debugf("No Transit Gateways to nuke in region %s", tgw.Region)
+		logging.Debugf("No Transit Gateways to nuke in region %s", tgw.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Transit Gateways in region %s", tgw.Region)
+	logging.Debugf("Deleting all Transit Gateways in region %s", tgw.Region)
 	var deletedIds []*string
 
 	for _, id := range ids {
@@ -57,7 +57,7 @@ func (tgw *TransitGateways) nukeAll(ids []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 			telemetry.TrackEvent(commonTelemetry.EventContext{
 				EventName: "Error Nuking Transit Gateway Instance",
 			}, map[string]interface{}{
@@ -65,11 +65,11 @@ func (tgw *TransitGateways) nukeAll(ids []*string) error {
 			})
 		} else {
 			deletedIds = append(deletedIds, id)
-			logging.Logger.Debugf("Deleted Transit Gateway: %s", *id)
+			logging.Debugf("Deleted Transit Gateway: %s", *id)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Transit Gateway(s) deleted in %s", len(deletedIds), tgw.Region)
+	logging.Debugf("[OK] %d Transit Gateway(s) deleted in %s", len(deletedIds), tgw.Region)
 	return nil
 }
 
@@ -106,11 +106,11 @@ func (tgw *TransitGatewaysRouteTables) getAll(c context.Context, configObj confi
 // Delete all TransitGatewayRouteTables
 func (tgw *TransitGatewaysRouteTables) nukeAll(ids []*string) error {
 	if len(ids) == 0 {
-		logging.Logger.Debugf("No Transit Gateway Route Tables to nuke in region %s", tgw.Region)
+		logging.Debugf("No Transit Gateway Route Tables to nuke in region %s", tgw.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Transit Gateway Route Tables in region %s", tgw.Region)
+	logging.Debugf("Deleting all Transit Gateway Route Tables in region %s", tgw.Region)
 	var deletedIds []*string
 
 	for _, id := range ids {
@@ -120,14 +120,14 @@ func (tgw *TransitGatewaysRouteTables) nukeAll(ids []*string) error {
 
 		_, err := tgw.Client.DeleteTransitGatewayRouteTable(param)
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 		} else {
 			deletedIds = append(deletedIds, id)
-			logging.Logger.Debugf("Deleted Transit Gateway Route Table: %s", *id)
+			logging.Debugf("Deleted Transit Gateway Route Table: %s", *id)
 		}
 	}
 
-	logging.Logger.Debugf("[OK] %d Transit Gateway Route Table(s) deleted in %s", len(deletedIds), tgw.Region)
+	logging.Debugf("[OK] %d Transit Gateway Route Table(s) deleted in %s", len(deletedIds), tgw.Region)
 	return nil
 }
 
@@ -152,11 +152,11 @@ func (tgw *TransitGatewaysVpcAttachment) getAll(c context.Context, configObj con
 // Delete all TransitGatewayVpcAttachments
 func (tgw *TransitGatewaysVpcAttachment) nukeAll(ids []*string) error {
 	if len(ids) == 0 {
-		logging.Logger.Debugf("No Transit Gateway Vpc Attachments to nuke in region %s", tgw.Region)
+		logging.Debugf("No Transit Gateway Vpc Attachments to nuke in region %s", tgw.Region)
 		return nil
 	}
 
-	logging.Logger.Debugf("Deleting all Transit Gateway Vpc Attachments in region %s", tgw.Region)
+	logging.Debugf("Deleting all Transit Gateway Vpc Attachments in region %s", tgw.Region)
 	var deletedIds []*string
 
 	for _, id := range ids {
@@ -175,13 +175,13 @@ func (tgw *TransitGatewaysVpcAttachment) nukeAll(ids []*string) error {
 		report.Record(e)
 
 		if err != nil {
-			logging.Logger.Debugf("[Failed] %s", err)
+			logging.Debugf("[Failed] %s", err)
 		} else {
 			deletedIds = append(deletedIds, id)
-			logging.Logger.Debugf("Deleted Transit Gateway Vpc Attachment: %s", *id)
+			logging.Debugf("Deleted Transit Gateway Vpc Attachment: %s", *id)
 		}
 	}
 
-	logging.Logger.Debugf(("[OK] %d Transit Gateway Vpc Attachment(s) deleted in %s"), len(deletedIds), tgw.Region)
+	logging.Debugf(("[OK] %d Transit Gateway Vpc Attachment(s) deleted in %s"), len(deletedIds), tgw.Region)
 	return nil
 }
diff --git a/commands/cli.go b/commands/cli.go
index 5e30170..a954462 100644
--- a/commands/cli.go
+++ b/commands/cli.go
@@ -16,7 +16,6 @@ import (
 	"github.com/gruntwork-io/cloud-nuke/ui"
 	"github.com/gruntwork-io/go-commons/errors"
 	"github.com/pterm/pterm"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -195,22 +194,6 @@ func parseDurationParam(paramValue string) (*time.Time, error) {
 	return &excludeAfter, nil
 }
 
-func parseLogLevel(c *cli.Context) error {
-	logLevel := c.String("log-level")
-
-	parsedLogLevel, err := logrus.ParseLevel(logLevel)
-	if err != nil {
-		return fmt.Errorf("Invalid log level - %s - %s", logLevel, err)
-	}
-	logging.Logger.SetLevel(parsedLogLevel)
-	if parsedLogLevel == logrus.DebugLevel {
-		pterm.EnableDebugMessages()
-		logging.Logger.Debugf("Setting log level to %s", parsedLogLevel.String())
-	}
-
-	return nil
-}
-
 func awsNuke(c *cli.Context) error {
 	telemetry.TrackEvent(commonTelemetry.EventContext{
 		EventName: "Start aws",
@@ -224,7 +207,7 @@ func awsNuke(c *cli.Context) error {
 		return handleListResourceTypes()
 	}
 
-	parseErr := parseLogLevel(c)
+	parseErr := logging.ParseLogLevel(c.String("log-level"))
 	if parseErr != nil {
 		return errors.WithStackTrace(parseErr)
 	}
@@ -265,7 +248,7 @@ func awsNuke(c *cli.Context) error {
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Skipping nuke, dryrun set",
 		}, map[string]interface{}{})
-		logging.Logger.Infoln("Not taking any action as dry-run set to true.")
+		logging.Info("Not taking any action as dry-run set to true.")
 		return nil
 	}
 
@@ -294,7 +277,7 @@ func awsNuke(c *cli.Context) error {
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Forcing nuke in 10 seconds",
 		}, map[string]interface{}{})
-		logging.Logger.Infoln("The --force flag is set, so waiting for 10 seconds before proceeding to nuke everything in your account. If you don't want to proceed, hit CTRL+C now!!")
+		logging.Info("The --force flag is set, so waiting for 10 seconds before proceeding to nuke everything in your account. If you don't want to proceed, hit CTRL+C now!!")
 		for i := 10; i > 0; i-- {
 			fmt.Printf("%d...", i)
 			time.Sleep(1 * time.Second)
@@ -317,18 +300,18 @@ func awsDefaults(c *cli.Context) error {
 	defer telemetry.TrackEvent(commonTelemetry.EventContext{
 		EventName: "End aws-defaults",
 	}, map[string]interface{}{})
-	parseErr := parseLogLevel(c)
+	parseErr := logging.ParseLogLevel(c.String("log-level"))
 	if parseErr != nil {
 		return errors.WithStackTrace(parseErr)
 	}
 
-	logging.Logger.Debugln("Identifying enabled regions")
+	logging.Debug("Identifying enabled regions")
 	regions, err := aws.GetEnabledRegions()
 	if err != nil {
 		return errors.WithStackTrace(err)
 	}
 	for _, region := range regions {
-		logging.Logger.Debugf("Found enabled region %s", region)
+		logging.Debugf("Found enabled region %s", region)
 	}
 
 	selectedRegions := c.StringSlice("region")
@@ -345,7 +328,7 @@ func awsDefaults(c *cli.Context) error {
 	}
 
 	if c.Bool("sg-only") {
-		logging.Logger.Info("Not removing default VPCs.")
+		logging.Info("Not removing default VPCs.")
 	} else {
 		telemetry.TrackEvent(commonTelemetry.EventContext{
 			EventName: "Nuking default VPCs",
@@ -395,7 +378,7 @@ func nukeDefaultVpcs(c *cli.Context, regions []string) error {
 	spinnerSuccess.Stop()
 
 	if len(vpcPerRegion) == 0 {
-		logging.Logger.Info("No default VPCs found.")
+		logging.Info("No default VPCs found.")
 		return nil
 	}
 
@@ -431,7 +414,7 @@ func nukeDefaultVpcs(c *cli.Context, regions []string) error {
 		progressbar.StartProgressBarWithLength(len(targetedRegionList))
 		err := resources.NukeVpcs(vpcPerRegion)
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 		}
 	}
 	return nil
@@ -456,7 +439,7 @@ func nukeDefaultSecurityGroups(c *cli.Context, regions []string) error {
 	}
 
 	if len(defaultSgs) == 0 {
-		logging.Logger.Info("No default security groups found.")
+		logging.Info("No default security groups found.")
 		return nil
 	}
 
@@ -491,7 +474,7 @@ func nukeDefaultSecurityGroups(c *cli.Context, regions []string) error {
 	if proceed || c.Bool("force") {
 		err := resources.NukeDefaultSecurityGroupRules(defaultSgs)
 		if err != nil {
-			logging.Logger.Errorf("[Failed] %s", err)
+			logging.Errorf("[Failed] %s", err)
 		}
 	}
 
diff --git a/config/config.go b/config/config.go
index 5b343a3..b530605 100644
--- a/config/config.go
+++ b/config/config.go
@@ -37,6 +37,7 @@ type Config struct {
 	EBSVolume                    ResourceType               `yaml:"EBSVolume"`
 	EC2                          ResourceType               `yaml:"EC2"`
 	EC2DedicatedHosts            ResourceType               `yaml:"EC2DedicatedHosts"`
+	EC2DHCPOption                ResourceType               `yaml:"EC2DhcpOption"`
 	EC2KeyPairs                  ResourceType               `yaml:"EC2KeyPairs"`
 	ECRRepository                ResourceType               `yaml:"ECRRepository"`
 	ECSCluster                   ResourceType               `yaml:"ECSCluster"`
diff --git a/logging/logger.go b/logging/logger.go
index 6efb4bd..2900d0e 100644
--- a/logging/logger.go
+++ b/logging/logger.go
@@ -1,6 +1,8 @@
 package logging
 
 import (
+	"fmt"
+	"github.com/pterm/pterm"
 	"github.com/sirupsen/logrus"
 	"os"
 )
@@ -17,3 +19,43 @@ func InitLogger() *logrus.Logger {
 	logger.SetOutput(os.Stdout)
 	return logger
 }
+
+// ParseLogLevel parses the log level from the CLI and sets the log level
+func ParseLogLevel(logLevel string) error {
+	parsedLogLevel, err := logrus.ParseLevel(logLevel)
+	if err != nil {
+		return fmt.Errorf("invalid log level - %s - %s", logLevel, err)
+	}
+
+	Logger.SetLevel(parsedLogLevel)
+	if parsedLogLevel == logrus.DebugLevel {
+		pterm.EnableDebugMessages()
+		Logger.Debugf("Setting log level to %s", parsedLogLevel.String())
+	}
+
+	return nil
+}
+
+func Debug(msg string) {
+	pterm.Debug.Println(msg)
+}
+
+func Debugf(msg string, args ...interface{}) {
+	Debug(fmt.Sprintf(msg, args...))
+}
+
+func Info(msg string) {
+	pterm.Info.Println(msg)
+}
+
+func Infof(msg string, args ...interface{}) {
+	Info(fmt.Sprintf(msg, args...))
+}
+
+func Error(msg string) {
+	pterm.Error.Println(msg)
+}
+
+func Errorf(msg string, args ...interface{}) {
+	Error(fmt.Sprintf(msg, args...))
+}
diff --git a/ui/ui.go b/ui/ui.go
index 847612b..7768839 100644
--- a/ui/ui.go
+++ b/ui/ui.go
@@ -125,7 +125,7 @@ func renderTableWithHeader(headers []string, data [][]string, w io.Writer) {
 		Render()
 
 	if renderErr != nil {
-		logging.Logger.Infof("Error rendering report table: %s\n", renderErr)
+		logging.Infof("Error rendering report table: %s\n", renderErr)
 	}
 }
 
@@ -217,7 +217,7 @@ func RenderNukeConfirmationPrompt(prompt string, numRetryCount int) (bool, error
 		confirmPrompt := pterm.DefaultInteractiveTextInput.WithMultiLine(false)
 		input, err := confirmPrompt.Show(prompt)
 		if err != nil {
-			logging.Logger.Errorf("[Failed to render prompt] %s", err)
+			logging.Errorf("[Failed to render prompt] %s", err)
 			return false, errors.WithStackTrace(err)
 		}
 
diff --git a/util/time.go b/util/time.go
index 59a65af..1983d06 100644
--- a/util/time.go
+++ b/util/time.go
@@ -26,7 +26,7 @@ func IsFirstSeenTag(key *string) bool {
 func ParseTimestampTag(timestamp *string) (*time.Time, error) {
 	parsed, err := time.Parse(firstSeenTimeFormat, aws.StringValue(timestamp))
 	if err != nil {
-		logging.Logger.Debugf("Error parsing the timestamp into a `RFC3339` Time format")
+		logging.Debugf("Error parsing the timestamp into a `RFC3339` Time format")
 		return nil, errors.WithStackTrace(err)
 
 	}


Test patch:
diff --git a/aws/resources/ec2_dhcp_option_test.go b/aws/resources/ec2_dhcp_option_test.go
new file mode 100644
index 0000000..e6c09b0
--- /dev/null
+++ b/aws/resources/ec2_dhcp_option_test.go
@@ -0,0 +1,79 @@
+package resources
+
+import (
+	"context"
+	awsgo "github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
+	"github.com/gruntwork-io/cloud-nuke/config"
+	"github.com/gruntwork-io/cloud-nuke/telemetry"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+type mockedEC2DhcpOption struct {
+	ec2iface.EC2API
+	DescribeDhcpOptionsOutput ec2.DescribeDhcpOptionsOutput
+	DeleteDhcpOptionsOutput   ec2.DeleteDhcpOptionsOutput
+}
+
+func (m mockedEC2DhcpOption) DescribeDhcpOptionsPages(input *ec2.DescribeDhcpOptionsInput, fn func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error {
+	fn(&m.DescribeDhcpOptionsOutput, true)
+	return nil
+}
+
+func (m mockedEC2DhcpOption) DeleteDhcpOptions(input *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) {
+	return &m.DeleteDhcpOptionsOutput, nil
+}
+
+func TestEC2DhcpOption_GetAll(t *testing.T) {
+	telemetry.InitTelemetry("cloud-nuke", "")
+	t.Parallel()
+
+	testId1 := "test-id-1"
+	h := EC2DhcpOption{
+		Client: mockedEC2DhcpOption{
+			DescribeDhcpOptionsOutput: ec2.DescribeDhcpOptionsOutput{
+				DhcpOptions: []*ec2.DhcpOptions{
+					{
+						DhcpOptionsId: awsgo.String(testId1),
+					},
+				},
+			},
+		},
+	}
+
+	tests := map[string]struct {
+		configObj config.ResourceType
+		expected  []string
+	}{
+		"emptyFilter": {
+			configObj: config.ResourceType{},
+			expected:  []string{testId1},
+		},
+	}
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			names, err := h.getAll(context.Background(), config.Config{
+				EC2DedicatedHosts: tc.configObj,
+			})
+			require.NoError(t, err)
+			require.Equal(t, tc.expected, awsgo.StringValueSlice(names))
+		})
+	}
+
+}
+
+func TestEC2DhcpOption_NukeAll(t *testing.T) {
+	telemetry.InitTelemetry("cloud-nuke", "")
+	t.Parallel()
+
+	h := EC2DhcpOption{
+		Client: mockedEC2DhcpOption{
+			DeleteDhcpOptionsOutput: ec2.DeleteDhcpOptionsOutput{},
+		},
+	}
+
+	err := h.nukeAll([]*string{awsgo.String("test-id-1"), awsgo.String("test-id-2")})
+	require.NoError(t, err)
+}
diff --git a/config/config_test.go b/config/config_test.go
index b4b159a..59b7374 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -53,6 +53,7 @@ func emptyConfig() *Config {
 		ResourceType{FilterRule{}, FilterRule{}},
 		ResourceType{FilterRule{}, FilterRule{}},
 		ResourceType{FilterRule{}, FilterRule{}},
+		ResourceType{FilterRule{}, FilterRule{}},
 		KMSCustomerKeyResourceType{false, ResourceType{FilterRule{}, FilterRule{}}},
 		ResourceType{FilterRule{}, FilterRule{}},
 		ResourceType{FilterRule{}, FilterRule{}},