diff --git a/tests/core/api/common.go b/tests/core/api/common.go
new file mode 100644
index 0000000..62f6a62
--- /dev/null
+++ b/tests/core/api/common.go
@@ -0,0 +1,33 @@
+// +build integration
+
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package api
+
+import (
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+var logger log.Logger
+
+func init() {
+	// Setup this package so that it's log level can be modified at run time
+	var err error
+	logger, err = log.AddPackage(log.JSON, log.ErrorLevel, log.Fields{"pkg": "api"})
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/tests/core/api/grpc_nbi_api_handler_client_test.go b/tests/core/api/grpc_nbi_api_handler_client_test.go
index 16ee92b..ac9da6c 100644
--- a/tests/core/api/grpc_nbi_api_handler_client_test.go
+++ b/tests/core/api/grpc_nbi_api_handler_client_test.go
@@ -50,29 +50,7 @@
 
 var devices map[string]*voltha.Device
 
-//func init() {
-//	log.AddPackage(log.JSON, log.ErrorLevel, nil)
-//	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-//	log.SetAllLogLevel(log.ErrorLevel)
-//
-//	//Start kafka and Etcd
-//	startKafkaEtcd()
-//	time.Sleep(10 * time.Second) //TODO: Find a better way to ascertain they are up
-//
-//	stub = setupGrpcConnection()
-//	stub = voltha.NewVolthaServiceClient(conn)
-//	devices = make(map[string]*voltha.Device)
-//}
-
 func setup() {
-	var err error
-
-	if _, err = log.AddPackage(log.JSON, log.WarnLevel, log.Fields{"instanceId": "testing"}); err != nil {
-		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
-	}
-	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-	log.SetAllLogLevel(log.ErrorLevel)
-
 	//Start kafka and Etcd
 	startKafka()
 	startEtcd()
@@ -90,7 +68,7 @@
 	var err error
 	conn, err = grpc.Dial(grpcHost, grpc.WithInsecure())
 	if err != nil {
-		log.Fatalf("did not connect: %s", err)
+		logger.Fatalf("did not connect: %s", err)
 	}
 	return voltha.NewVolthaServiceClient(conn)
 }
@@ -99,7 +77,7 @@
 	for key, _ := range devices {
 		ctx := context.Background()
 		response, err := stub.DeleteDevice(ctx, &voltha.ID{Id: key})
-		log.Infow("response", log.Fields{"res": response, "error": err})
+		logger.Infow("response", log.Fields{"res": response, "error": err})
 		if clearMap {
 			delete(devices, key)
 		}
@@ -127,7 +105,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/docker-compose-zk-kafka-test.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -136,7 +114,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/docker-compose-etcd.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -147,7 +125,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -158,7 +136,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -167,7 +145,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/rw_core.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -178,7 +156,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -187,7 +165,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/adapters-simulated.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -198,7 +176,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -219,7 +197,7 @@
 		ctx := context.Background()
 		device := &voltha.Device{Type: "simulated_olt"}
 		response, err := stub.CreateDevice(ctx, device)
-		log.Infow("response", log.Fields{"res": response, "error": err})
+		logger.Infow("response", log.Fields{"res": response, "error": err})
 		assert.NotNil(t, response)
 		assert.Nil(t, err)
 		devices[response.Id] = response
@@ -228,7 +206,7 @@
 	//3. Verify devices have been added correctly
 	ctx := context.Background()
 	response, err := stub.ListDeviceIds(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.True(t, hasAllIds(response))
 
@@ -258,14 +236,14 @@
 		ctx := context.Background()
 		device := &voltha.Device{Type: "simulated_olt"}
 		response, err := stub.CreateDevice(ctx, device)
-		log.Infow("response", log.Fields{"res": response, "error": err})
+		logger.Infow("response", log.Fields{"res": response, "error": err})
 		assert.Nil(t, err)
 		devices[response.Id] = response
 	}
 	//3. Verify devices have been added correctly
 	ctx := context.Background()
 	response, err := stub.ListDeviceIds(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.True(t, hasAllIds(response))
 
@@ -282,7 +260,7 @@
 	//6. Verify there are no devices left
 	ctx = context.Background()
 	response, err = stub.ListDeviceIds(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.Equal(t, len(response.Items), 0)
 
@@ -298,7 +276,7 @@
 	//8. Verify all devices have been restored
 	ctx = context.Background()
 	response, err = stub.ListDeviceIds(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.True(t, hasAllIds(response))
 
@@ -340,7 +318,7 @@
 		randomMacAddress := strings.ToUpper(com.GetRandomMacAddress())
 		device := &voltha.Device{Type: "simulated_olt", MacAddress: randomMacAddress}
 		response, err := stub.CreateDevice(ctx, device)
-		log.Infow("response", log.Fields{"res": response, "error": err})
+		logger.Infow("response", log.Fields{"res": response, "error": err})
 		assert.Nil(t, err)
 		devices[response.Id] = response
 	}
@@ -349,7 +327,7 @@
 	for id, _ := range devices {
 		ctx := context.Background()
 		response, err := stub.EnableDevice(ctx, &common.ID{Id: id})
-		log.Infow("response", log.Fields{"res": response, "error": err})
+		logger.Infow("response", log.Fields{"res": response, "error": err})
 		assert.Nil(t, err)
 	}
 
@@ -366,7 +344,7 @@
 	//5. Verify that all devices are in enabled state
 	ctx := context.Background()
 	response, err := stub.ListDevices(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.Equal(t, len(devices)*2, len(response.Items))
 	for _, d := range response.Items {
@@ -377,7 +355,7 @@
 	//6. Get the logical devices
 	ctx = context.Background()
 	lresponse, lerr := stub.ListLogicalDevices(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": lerr})
+	logger.Infow("response", log.Fields{"res": response, "error": lerr})
 	assert.Nil(t, lerr)
 	assert.Equal(t, numberOfOLTDevices, len(lresponse.Items))
 	for _, ld := range lresponse.Items {
@@ -391,7 +369,7 @@
 		ctx := context.Background()
 		if d.Type == "simulated_onu" {
 			response, err := stub.DisableDevice(ctx, &common.ID{Id: id})
-			log.Infow("response", log.Fields{"res": response, "error": err})
+			logger.Infow("response", log.Fields{"res": response, "error": err})
 			assert.Nil(t, err)
 		}
 	}
@@ -401,7 +379,7 @@
 
 	ctx = context.Background()
 	response, err = stub.ListDevices(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.Equal(t, len(devices), len(response.Items))
 	for _, d := range response.Items {
@@ -415,7 +393,7 @@
 
 	ctx = context.Background()
 	lresponse, lerr = stub.ListLogicalDevices(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": lerr})
+	logger.Infow("response", log.Fields{"res": response, "error": lerr})
 	assert.Nil(t, lerr)
 	assert.Equal(t, numberOfOLTDevices, len(lresponse.Items))
 	for _, ld := range lresponse.Items {
@@ -429,7 +407,7 @@
 		ctx := context.Background()
 		if d.Type == "simulated_onu" {
 			response, err := stub.EnableDevice(ctx, &common.ID{Id: id})
-			log.Infow("response", log.Fields{"res": response, "error": err})
+			logger.Infow("response", log.Fields{"res": response, "error": err})
 			assert.Nil(t, err)
 		}
 	}
@@ -439,7 +417,7 @@
 
 	ctx = context.Background()
 	response, err = stub.ListDevices(ctx, &empty.Empty{})
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	assert.Equal(t, len(devices), len(response.Items))
 	for _, d := range response.Items {
@@ -449,7 +427,7 @@
 
 	//ctx = context.Background()
 	//lresponse, lerr = stub.ListLogicalDevices(ctx, &empty.Empty{})
-	//log.Infow("response", log.Fields{"res": response, "error": lerr})
+	//logger.Infow("response", log.Fields{"res": response, "error": lerr})
 	//assert.Nil(t, lerr)
 	//assert.Equal(t, numberOfOLTDevices, len(lresponse.Items))
 	//for _, ld := range (lresponse.Items) {
@@ -492,7 +470,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	level := voltha.Logging{PackageName: "github.com/opencord/voltha-go/rw_core/core", Level: common.LogLevel_ERROR}
 	response, err := stub.UpdateLogLevel(ctx, &level)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -509,7 +487,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	level := voltha.Logging{PackageName: "github.com/opencord/voltha-go/rw_core/core", Level: common.LogLevel_DEBUG}
 	response, err := stub.UpdateLogLevel(ctx, &level)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -601,7 +579,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	device := &voltha.Device{Id: "newdevice"}
 	response, err := stub.CreateDevice(ctx, device)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &voltha.Device{Id: "newdevice"}, response)
 	assert.Nil(t, err)
 }
@@ -610,7 +588,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	id := &voltha.ID{Id: "enabledevice"}
 	response, err := stub.EnableDevice(ctx, id)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -619,7 +597,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	id := &voltha.ID{Id: "DisableDevice"}
 	response, err := stub.DisableDevice(ctx, id)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -628,7 +606,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	id := &voltha.ID{Id: "RebootDevice"}
 	response, err := stub.RebootDevice(ctx, id)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -637,7 +615,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	id := &voltha.ID{Id: "DeleteDevice"}
 	response, err := stub.DeleteDevice(ctx, id)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -647,9 +625,9 @@
 	id := &voltha.LogicalPortId{Id: "EnableLogicalDevicePort"}
 	response, err := stub.EnableLogicalDevicePort(ctx, id)
 	if e, ok := status.FromError(err); ok {
-		log.Infow("response", log.Fields{"error": err, "errorcode": e.Code(), "msg": e.Message()})
+		logger.Infow("response", log.Fields{"error": err, "errorcode": e.Code(), "msg": e.Message()})
 	}
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -658,7 +636,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	id := &voltha.LogicalPortId{Id: "DisableLogicalDevicePort"}
 	response, err := stub.DisableLogicalDevicePort(ctx, id)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
@@ -667,7 +645,7 @@
 	ctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs(testMode, "true"))
 	flow := &openflow_13.FlowGroupTableUpdate{Id: "UpdateLogicalDeviceFlowGroupTable"}
 	response, err := stub.UpdateLogicalDeviceFlowGroupTable(ctx, flow)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Equal(t, &empty.Empty{}, response)
 	assert.Nil(t, err)
 }
diff --git a/tests/core/common.go b/tests/core/common.go
new file mode 100644
index 0000000..d22a68b
--- /dev/null
+++ b/tests/core/common.go
@@ -0,0 +1,33 @@
+// +build integration
+
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+var logger log.Logger
+
+func init() {
+	// Setup this package so that it's log level can be modified at run time
+	var err error
+	logger, err = log.AddPackage(log.JSON, log.ErrorLevel, log.Fields{"pkg": "core"})
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/tests/core/concurrency/common_test.go b/tests/core/concurrency/common_test.go
new file mode 100644
index 0000000..ccf2126
--- /dev/null
+++ b/tests/core/concurrency/common_test.go
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package concurrency
+
+import (
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+var logger log.Logger
+
+func init() {
+	// Setup this package so that it's log level can be modified at run time
+	var err error
+	logger, err = log.AddPackage(log.JSON, log.ErrorLevel, log.Fields{"pkg": "concurrency"})
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/tests/core/concurrency/core_concurrency_test.go b/tests/core/concurrency/core_concurrency_test.go
index c8ddff2..b5ab176 100644
--- a/tests/core/concurrency/core_concurrency_test.go
+++ b/tests/core/concurrency/core_concurrency_test.go
@@ -49,14 +49,6 @@
 var devices map[string]*voltha.Device
 
 func setup() {
-	var err error
-
-	if _, err = log.AddPackage(log.JSON, log.WarnLevel, log.Fields{"instanceId": "testing"}); err != nil {
-		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
-	}
-	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-	log.SetAllLogLevel(log.ErrorLevel)
-
 	grpcPorts = []int{50057, 50058}
 	stubs = make([]voltha.VolthaServiceClient, 0)
 	conns = make([]*grpc.ClientConn, 0)
@@ -70,7 +62,7 @@
 	grpcHost := fmt.Sprintf("%s:%d", grpcHostIP, port)
 	conn, err := grpc.Dial(grpcHost, grpc.WithInsecure())
 	if err != nil {
-		log.Fatalf("did not connect: %s", err)
+		logger.Fatalf("did not connect: %s", err)
 		return nil, errors.New("failure-to-connect")
 	}
 	conns = append(conns, conn)
@@ -82,7 +74,7 @@
 	for _, port := range grpcPorts {
 		if client, err := connectToCore(port); err == nil {
 			stubs = append(stubs, client)
-			log.Infow("connected", log.Fields{"port": port})
+			logger.Infow("connected", log.Fields{"port": port})
 		}
 	}
 	return stubs
@@ -92,7 +84,7 @@
 	for key, _ := range devices {
 		ctx := context.Background()
 		response, err := stubs[1].DeleteDevice(ctx, &voltha.ID{Id: key})
-		log.Infow("response", log.Fields{"res": response, "error": err})
+		logger.Infow("response", log.Fields{"res": response, "error": err})
 		if clearMap {
 			delete(devices, key)
 		}
@@ -120,7 +112,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/docker-compose-zk-kafka-test.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -129,7 +121,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/docker-compose-etcd.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -140,7 +132,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -151,7 +143,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -160,7 +152,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/rw_core_concurrency_test.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -171,7 +163,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -180,7 +172,7 @@
 	command := "docker-compose"
 	cmd := exec.Command(command, "-f", "../../../compose/adapters-simulated.yml", "up", "-d")
 	if err := cmd.Run(); err != nil {
-		log.Fatal(err)
+		logger.Fatal(err)
 	}
 }
 
@@ -191,7 +183,7 @@
 	if err := cmd.Run(); err != nil {
 		// ignore error - as this is mostly due network being left behind as its being used by other
 		// containers
-		log.Warn(err)
+		logger.Warn(err)
 	}
 }
 
@@ -350,7 +342,7 @@
 
 	//3.  Create the devices
 	response, err := createDevice(stubs)
-	log.Infow("response", log.Fields{"res": response, "error": err})
+	logger.Infow("response", log.Fields{"res": response, "error": err})
 	assert.Nil(t, err)
 	devices[response.Id] = response
 
diff --git a/tests/core/flow_management_test.go b/tests/core/flow_management_test.go
index dbd9ab7..7a1079d 100644
--- a/tests/core/flow_management_test.go
+++ b/tests/core/flow_management_test.go
@@ -71,14 +71,6 @@
 )
 
 func setup() {
-	var err error
-
-	if _, err = log.AddPackage(log.JSON, log.WarnLevel, log.Fields{"instanceId": "testing"}); err != nil {
-		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
-	}
-	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-	log.SetAllLogLevel(log.ErrorLevel)
-
 	volthaSerialNumberKey = "voltha_serial_number"
 	allDevices = make(map[string]*voltha.Device)
 	allLogicalDevices = make(map[string]*voltha.LogicalDevice)
diff --git a/tests/core/performance_metrics_test.go b/tests/core/performance_metrics_test.go
index 6827068..60b0bba 100644
--- a/tests/core/performance_metrics_test.go
+++ b/tests/core/performance_metrics_test.go
@@ -91,14 +91,6 @@
 }
 
 func setup() {
-	var err error
-
-	if _, err = log.AddPackage(log.JSON, log.WarnLevel, log.Fields{"instanceId": "testing"}); err != nil {
-		log.With(log.Fields{"error": err}).Fatal("Cannot setup logging")
-	}
-	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-	log.SetAllLogLevel(log.ErrorLevel)
-
 	volthaSerialNumberKey = "voltha_serial_number"
 	allDevices = make(map[string]*voltha.Device)
 	allLogicalDevices = make(map[string]*voltha.LogicalDevice)
diff --git a/tests/kafka/common.go b/tests/kafka/common.go
new file mode 100644
index 0000000..ef4d06a
--- /dev/null
+++ b/tests/kafka/common.go
@@ -0,0 +1,33 @@
+// +build integration
+
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package kafka
+
+import (
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+var logger log.Logger
+
+func init() {
+	// Setup this package so that it's log level can be modified at run time
+	var err error
+	logger, err = log.AddPackage(log.JSON, log.ErrorLevel, log.Fields{"pkg": "kafka"})
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/tests/kafka/kafka_client_test.go b/tests/kafka/kafka_client_test.go
index a553283..cdc2827 100644
--- a/tests/kafka/kafka_client_test.go
+++ b/tests/kafka/kafka_client_test.go
@@ -45,10 +45,7 @@
 type sendToKafka func(interface{}, *kk.Topic, ...string) error
 
 func init() {
-	log.AddPackage(log.JSON, log.ErrorLevel, nil)
 	hostIP := os.Getenv("DOCKER_HOST_IP")
-	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-	log.SetAllLogLevel(log.ErrorLevel)
 	partionClient = kk.NewSaramaClient(
 		kk.ConsumerType(kk.PartitionConsumer),
 		kk.Host(hostIP),
@@ -78,7 +75,7 @@
 				mytime = time.Now()
 			}
 			totalTime = totalTime + (time.Now().UnixNano()-msg.Header.Timestamp)/int64(time.Millisecond)
-			//log.Debugw("msg-received", log.Fields{"msg":msg})
+			//logger.Debugw("msg-received", log.Fields{"msg":msg})
 			totalMessageReceived = totalMessageReceived + 1
 			if totalMessageReceived == maxMessages {
 				doneCh <- "All received"
@@ -89,7 +86,7 @@
 			}
 		}
 	}
-	log.Infow("Received all messages", log.Fields{"total": time.Since(mytime)})
+	logger.Infow("Received all messages", log.Fields{"total": time.Since(mytime)})
 }
 
 func sendMessages(topic *kk.Topic, numMessages int, fn sendToKafka) error {
@@ -107,7 +104,7 @@
 		var err error
 		body := &ic.InterContainerRequestBody{Rpc: "testRPC", Args: []*ic.Argument{}}
 		if marshalledArg, err = ptypes.MarshalAny(body); err != nil {
-			log.Warnw("cannot-marshal-request", log.Fields{"error": err})
+			logger.Warnw("cannot-marshal-request", log.Fields{"error": err})
 			return err
 		}
 		msg.Body = marshalledArg
@@ -157,7 +154,7 @@
 	assert.Nil(t, err)
 	partionClient.Stop()
 	assert.Equal(t, numMessageToSend, totalMessageReceived)
-	log.Infow("Partition consumer completed", log.Fields{"TotalMesages": totalMessageReceived, "TotalTime": totalTime, "val": val, "AverageTime": totalTime / int64(totalMessageReceived), "execTime": time.Since(start)})
+	logger.Infow("Partition consumer completed", log.Fields{"TotalMesages": totalMessageReceived, "TotalTime": totalTime, "val": val, "AverageTime": totalTime / int64(totalMessageReceived), "execTime": time.Since(start)})
 }
 
 func TestGroupConsumer(t *testing.T) {
@@ -171,7 +168,7 @@
 	assert.Nil(t, err)
 	groupClient.Stop()
 	assert.Equal(t, numMessageToSend, totalMessageReceived)
-	log.Infow("Group consumer completed", log.Fields{"TotalMesages": totalMessageReceived, "TotalTime": totalTime, "val": val, "AverageTime": totalTime / int64(totalMessageReceived), "execTime": time.Since(start)})
+	logger.Infow("Group consumer completed", log.Fields{"TotalMesages": totalMessageReceived, "TotalTime": totalTime, "val": val, "AverageTime": totalTime / int64(totalMessageReceived), "execTime": time.Since(start)})
 
 }
 
diff --git a/tests/kafka/kafka_inter_container_messaging_test.go b/tests/kafka/kafka_inter_container_messaging_test.go
index 7a7a9d6..9836793 100644
--- a/tests/kafka/kafka_inter_container_messaging_test.go
+++ b/tests/kafka/kafka_inter_container_messaging_test.go
@@ -48,9 +48,6 @@
 var kafkaClient kk.Client
 
 func init() {
-	log.AddPackage(log.JSON, log.ErrorLevel, nil)
-	log.UpdateAllLoggers(log.Fields{"instanceId": "testing"})
-	log.SetAllLogLevel(log.ErrorLevel)
 	affinityRouterTopic = "AffinityRouter"
 	hostIP = os.Getenv("DOCKER_HOST_IP")
 	kafkaClient = kk.NewSaramaClient(
@@ -91,7 +88,7 @@
 
 func waitForRPCMessage(topic kk.Topic, ch <-chan *ic.InterContainerMessage, doneCh chan string) {
 	for msg := range ch {
-		log.Debugw("Got-RPC-message", log.Fields{"msg": msg})
+		logger.Debugw("Got-RPC-message", log.Fields{"msg": msg})
 		//	Unpack message
 		requestBody := &ic.InterContainerRequestBody{}
 		if err := ptypes.UnmarshalAny(msg.Body, requestBody); err != nil {
@@ -178,12 +175,12 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, false)
 	//Unpack the result into the actual proto object
 	unpackResult := &ic.Error{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.NotNil(t, unpackResult)
 }
@@ -201,12 +198,12 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, false)
 	//Unpack the result into the actual proto object
 	unpackResult := &ic.Error{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.NotNil(t, unpackResult)
 }
@@ -228,11 +225,11 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(ctx, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	unpackResult := &voltha.Device{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.Equal(t, unpackResult, expectedResponse)
 }
@@ -253,11 +250,11 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(ctx, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, false)
 	unpackResult := &ic.Error{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.NotNil(t, unpackResult)
 }
@@ -276,11 +273,11 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	unpackResult := &voltha.Device{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.Equal(t, unpackResult, expectedResponse)
 }
@@ -299,11 +296,11 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	unpackResult := &voltha.Device{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.Equal(t, unpackResult, expectedResponse)
 }
@@ -326,11 +323,11 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	unpackResult := &voltha.Ports{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	expectedLen := len(unpackResult.Items) >= 1
 	assert.Equal(t, true, expectedLen)
@@ -349,12 +346,12 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, false)
 	//Unpack the result into the actual proto object
 	unpackResult := &ic.Error{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.NotNil(t, unpackResult)
 }
@@ -393,7 +390,7 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	assert.Nil(t, result)
 }
@@ -432,7 +429,7 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, false, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	assert.Nil(t, result)
 }
@@ -461,11 +458,11 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, false)
 	unpackResult := &ic.Error{}
 	if err := ptypes.UnmarshalAny(result, unpackResult); err != nil {
-		log.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
+		logger.Warnw("cannot-unmarshal-response", log.Fields{"error": err})
 	}
 	assert.NotNil(t, unpackResult)
 }
@@ -495,7 +492,7 @@
 	start := time.Now()
 	status, result := adapterKafkaProxy.InvokeRPC(nil, rpc, &topic, &topic, true, TEST_RPC_KEY, args...)
 	elapsed := time.Since(start)
-	log.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
+	logger.Infow("Result", log.Fields{"status": status, "result": result, "time": elapsed})
 	assert.Equal(t, status, true)
 	assert.Nil(t, result)
 }
@@ -508,7 +505,7 @@
 	}
 	msg := <-ch
 
-	log.Debugw("msg-received", log.Fields{"msg": msg})
+	logger.Debugw("msg-received", log.Fields{"msg": msg})
 	waitingChannel <- msg
 	return nil
 }
@@ -543,7 +540,7 @@
 	assert.Equal(t, dd.DeviceType, "TestDevicetype")
 	assert.Equal(t, dd.ParentId, "TestParentId")
 	assert.Equal(t, dd.Publisher, "myPODName")
-	log.Debugw("TotalTime", log.Fields{"time": totalTime})
+	logger.Debugw("TotalTime", log.Fields{"time": totalTime})
 }
 
 func TestStopKafkaProxy(t *testing.T) {
@@ -552,5 +549,5 @@
 }
 
 //func TestMain(m *testing.T) {
-//	log.Info("Main")
+//	logger.Info("Main")
 //}
diff --git a/tests/utils/common.go b/tests/utils/common.go
new file mode 100644
index 0000000..bef91e2
--- /dev/null
+++ b/tests/utils/common.go
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package utils Common Logger initialization
+package utils
+
+import (
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+var logger log.Logger
+
+func init() {
+	// Setup this package so that it's log level can be modified at run time
+	var err error
+	logger, err = log.AddPackage(log.JSON, log.ErrorLevel, log.Fields{"pkg": "utils"})
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/tests/utils/test_utils.go b/tests/utils/test_utils.go
index 655e942..3aaf89b 100644
--- a/tests/utils/test_utils.go
+++ b/tests/utils/test_utils.go
@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-package core
+package utils
 
 import (
 	"context"
@@ -455,19 +455,19 @@
 func StopSimulatedEnv(composePath string) error {
 	err := stopSimulatedOLTAndONUAdapters(composePath)
 	if err != nil {
-		log.Errorw("unable-to-stop-simulated-olt-onu-adapters", log.Fields{"error": err})
+		logger.Errorw("unable-to-stop-simulated-olt-onu-adapters", log.Fields{"error": err})
 	}
 	err = stopCore(composePath)
 	if err != nil {
-		log.Errorw("unable-to-stop-core", log.Fields{"error": err})
+		logger.Errorw("unable-to-stop-core", log.Fields{"error": err})
 	}
 	err = stopKafka(composePath)
 	if err != nil {
-		log.Errorw("unable-to-stop-kafka", log.Fields{"error": err})
+		logger.Errorw("unable-to-stop-kafka", log.Fields{"error": err})
 	}
 	err = stopEtcd(composePath)
 	if err != nil {
-		log.Errorw("unable-to-stop-etcd", log.Fields{"error": err})
+		logger.Errorw("unable-to-stop-etcd", log.Fields{"error": err})
 	}
 	return nil
 }