diff --git a/rw_core/test/common.go b/rw_core/test/common.go
index a20f029..f27527e 100644
--- a/rw_core/test/common.go
+++ b/rw_core/test/common.go
@@ -21,12 +21,12 @@
 	"github.com/opencord/voltha-lib-go/v3/pkg/log"
 )
 
-var logger log.Logger
+var logger log.CLogger
 
 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": "test"})
+	logger, err = log.RegisterPackage(log.JSON, log.ErrorLevel, log.Fields{"pkg": "test"})
 	if err != nil {
 		panic(err)
 	}
diff --git a/rw_core/test/utils.go b/rw_core/test/utils.go
index b831e4c..f2e6229 100644
--- a/rw_core/test/utils.go
+++ b/rw_core/test/utils.go
@@ -18,6 +18,7 @@
 package test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/opencord/voltha-go/rw_core/config"
@@ -43,39 +44,39 @@
 )
 
 //CreateMockAdapter creates mock OLT and ONU adapters
-func CreateMockAdapter(adapterType int, kafkaClient kafka.Client, coreInstanceID string, coreName string, adapterName string) (adapters.IAdapter, error) {
+func CreateMockAdapter(ctx context.Context, adapterType int, kafkaClient kafka.Client, coreInstanceID string, coreName string, adapterName string) (adapters.IAdapter, error) {
 	var err error
 	var adapter adapters.IAdapter
 	adapterKafkaICProxy := kafka.NewInterContainerProxy(
 		kafka.MsgClient(kafkaClient),
 		kafka.DefaultTopic(&kafka.Topic{Name: adapterName}))
-	adapterCoreProxy := com.NewCoreProxy(adapterKafkaICProxy, adapterName, coreName)
+	adapterCoreProxy := com.NewCoreProxy(ctx, adapterKafkaICProxy, adapterName, coreName)
 	var adapterReqHandler *com.RequestHandlerProxy
 	switch adapterType {
 	case OltAdapter:
-		adapter = cm.NewOLTAdapter(adapterCoreProxy)
+		adapter = cm.NewOLTAdapter(ctx, adapterCoreProxy)
 	case OnuAdapter:
-		adapter = cm.NewONUAdapter(adapterCoreProxy)
+		adapter = cm.NewONUAdapter(ctx, adapterCoreProxy)
 	default:
-		logger.Fatalf("invalid-adapter-type-%d", adapterType)
+		logger.Fatalf(ctx, "invalid-adapter-type-%d", adapterType)
 	}
 	adapterReqHandler = com.NewRequestHandlerProxy(coreInstanceID, adapter, adapterCoreProxy)
 
-	if err = adapterKafkaICProxy.Start(); err != nil {
-		logger.Errorw("Failure-starting-adapter-intercontainerProxy", log.Fields{"error": err})
+	if err = adapterKafkaICProxy.Start(ctx); err != nil {
+		logger.Errorw(ctx, "Failure-starting-adapter-intercontainerProxy", log.Fields{"error": err})
 		return nil, err
 	}
-	if err = adapterKafkaICProxy.SubscribeWithRequestHandlerInterface(kafka.Topic{Name: adapterName}, adapterReqHandler); err != nil {
-		logger.Errorw("Failure-to-subscribe-onu-request-handler", log.Fields{"error": err})
+	if err = adapterKafkaICProxy.SubscribeWithRequestHandlerInterface(ctx, kafka.Topic{Name: adapterName}, adapterReqHandler); err != nil {
+		logger.Errorw(ctx, "Failure-to-subscribe-onu-request-handler", log.Fields{"error": err})
 		return nil, err
 	}
 	return adapter, nil
 }
 
 //CreateAndregisterAdapters creates mock ONU and OLT adapters and egisters them to rw-core
-func CreateAndregisterAdapters(t *testing.T, kClient kafka.Client, coreInstanceID string, oltAdapterName string, onuAdapterName string, adapterMgr *adapter.Manager) (*cm.OLTAdapter, *cm.ONUAdapter) {
+func CreateAndregisterAdapters(ctx context.Context, t *testing.T, kClient kafka.Client, coreInstanceID string, oltAdapterName string, onuAdapterName string, adapterMgr *adapter.Manager) (*cm.OLTAdapter, *cm.ONUAdapter) {
 	// Setup the mock OLT adapter
-	oltAdapter, err := CreateMockAdapter(OltAdapter, kClient, coreInstanceID, "rw_core", oltAdapterName)
+	oltAdapter, err := CreateMockAdapter(ctx, OltAdapter, kClient, coreInstanceID, "rw_core", oltAdapterName)
 	assert.Nil(t, err)
 	assert.NotNil(t, oltAdapter)
 
@@ -91,13 +92,13 @@
 	}
 	types := []*voltha.DeviceType{{Id: oltAdapterName, Adapter: oltAdapterName, AcceptsAddRemoveFlowUpdates: true}}
 	deviceTypes := &voltha.DeviceTypes{Items: types}
-	if _, err := adapterMgr.RegisterAdapter(registrationData, deviceTypes); err != nil {
-		logger.Errorw("failed-to-register-adapter", log.Fields{"error": err})
+	if _, err := adapterMgr.RegisterAdapter(ctx, registrationData, deviceTypes); err != nil {
+		logger.Errorw(ctx, "failed-to-register-adapter", log.Fields{"error": err})
 		assert.NotNil(t, err)
 	}
 
 	// Setup the mock ONU adapter
-	onuAdapter, err := CreateMockAdapter(OnuAdapter, kClient, coreInstanceID, "rw_core", onuAdapterName)
+	onuAdapter, err := CreateMockAdapter(ctx, OnuAdapter, kClient, coreInstanceID, "rw_core", onuAdapterName)
 
 	assert.Nil(t, err)
 	assert.NotNil(t, onuAdapter)
@@ -113,15 +114,15 @@
 	}
 	types = []*voltha.DeviceType{{Id: onuAdapterName, Adapter: onuAdapterName, AcceptsAddRemoveFlowUpdates: true}}
 	deviceTypes = &voltha.DeviceTypes{Items: types}
-	if _, err := adapterMgr.RegisterAdapter(registrationData, deviceTypes); err != nil {
-		logger.Errorw("failed-to-register-adapter", log.Fields{"error": err})
+	if _, err := adapterMgr.RegisterAdapter(ctx, registrationData, deviceTypes); err != nil {
+		logger.Errorw(ctx, "failed-to-register-adapter", log.Fields{"error": err})
 		assert.NotNil(t, err)
 	}
 	return oltAdapter.(*cm.OLTAdapter), onuAdapter.(*cm.ONUAdapter)
 }
 
 //StartEmbeddedEtcdServer creates and starts an Embedded etcd server locally.
-func StartEmbeddedEtcdServer(configName, storageDir, logLevel string) (*mock_etcd.EtcdServer, int, error) {
+func StartEmbeddedEtcdServer(ctx context.Context, configName, storageDir, logLevel string) (*mock_etcd.EtcdServer, int, error) {
 	kvClientPort, err := freeport.GetFreePort()
 	if err != nil {
 		return nil, 0, err
@@ -130,7 +131,7 @@
 	if err != nil {
 		return nil, 0, err
 	}
-	etcdServer := mock_etcd.StartEtcdServer(mock_etcd.MKConfig(configName, kvClientPort, peerPort, storageDir, logLevel))
+	etcdServer := mock_etcd.StartEtcdServer(ctx, mock_etcd.MKConfig(ctx, configName, kvClientPort, peerPort, storageDir, logLevel))
 	if etcdServer == nil {
 		return nil, 0, status.Error(codes.Internal, "Embedded server failed to start")
 	}
@@ -138,15 +139,15 @@
 }
 
 //StopEmbeddedEtcdServer stops the embedded etcd server
-func StopEmbeddedEtcdServer(server *mock_etcd.EtcdServer) {
+func StopEmbeddedEtcdServer(ctx context.Context, server *mock_etcd.EtcdServer) {
 	if server != nil {
-		server.Stop()
+		server.Stop(ctx)
 	}
 }
 
 //SetupKVClient creates a new etcd client
-func SetupKVClient(cf *config.RWCoreFlags, coreInstanceID string) kvstore.Client {
-	client, err := kvstore.NewEtcdClient(cf.KVStoreAddress, cf.KVStoreTimeout, log.FatalLevel)
+func SetupKVClient(ctx context.Context, cf *config.RWCoreFlags, coreInstanceID string) kvstore.Client {
+	client, err := kvstore.NewEtcdClient(ctx, cf.KVStoreAddress, cf.KVStoreTimeout, log.FatalLevel)
 	if err != nil {
 		panic("no kv client")
 	}