diff --git a/internal/pkg/core/device_handler.go b/internal/pkg/core/device_handler.go
index 00b339d..05e85ff 100755
--- a/internal/pkg/core/device_handler.go
+++ b/internal/pkg/core/device_handler.go
@@ -30,13 +30,13 @@
 	"sync"
 	"time"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/opencord/voltha-lib-go/v7/pkg/db"
 	"github.com/opencord/voltha-lib-go/v7/pkg/db/kvstore"
 
 	vgrpc "github.com/opencord/voltha-lib-go/v7/pkg/grpc"
 
 	"github.com/cenkalti/backoff/v3"
-	"github.com/gogo/protobuf/proto"
 	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
 	grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
@@ -215,14 +215,14 @@
 	dh.cm = cm
 	dh.coreClient = cc
 	dh.EventProxy = ep
-	cloned := (proto.Clone(device)).(*voltha.Device)
-	dh.device = cloned
+	// Note: We use the device directly instead of cloning to avoid issues with protobuf unexported fields
+	dh.device = device
 	dh.openOLT = adapter
 	dh.exitChannel = make(chan struct{})
 	dh.lockDevice = sync.RWMutex{}
 	dh.stopCollector = make(chan bool, 1)      // TODO: Why buffered?
 	dh.stopHeartbeatCheck = make(chan bool, 1) // TODO: Why buffered?
-	dh.metrics = pmmetrics.NewPmMetrics(cloned.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
+	dh.metrics = pmmetrics.NewPmMetrics(device.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
 	dh.activePorts = sync.Map{}
 	dh.stopIndications = make(chan bool, 1) // TODO: Why buffered?
 	dh.perPonOnuIndicationChannel = make(map[uint32]onuIndicationChannels)
@@ -1153,18 +1153,16 @@
 		return olterrors.NewErrNotFound("device", log.Fields{"device-id": dh.device.Id}, err)
 	}
 
-	cloned := proto.Clone(device).(*voltha.Device)
-
 	// Update the device oper state and connection status
-	cloned.OperStatus = voltha.OperStatus_UNKNOWN
+	device.OperStatus = voltha.OperStatus_UNKNOWN
 	dh.lockDevice.Lock()
-	dh.device = cloned
+	dh.device = device
 	dh.lockDevice.Unlock()
 
 	if err = dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{
-		DeviceId:   cloned.Id,
-		OperStatus: cloned.OperStatus,
-		ConnStatus: cloned.ConnectStatus,
+		DeviceId:   device.Id,
+		OperStatus: device.OperStatus,
+		ConnStatus: device.ConnectStatus,
 	}); err != nil {
 		return olterrors.NewErrAdapter("state-update-failed", log.Fields{"device-id": device.Id}, err)
 	}
@@ -1192,7 +1190,7 @@
 		if err != nil {
 			_ = olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
 				"source":        dh.openOLT.config.AdapterEndpoint,
-				"onu-indicator": onuInd,
+				"onu-indicator": onuInd.String(),
 				"device-type":   onuDevice.Type,
 				"device-id":     onuDevice.Id}, err).LogAt(log.ErrorLevel)
 			// Do not return here and continue to process other ONUs
@@ -1285,15 +1283,14 @@
 	if device.AdminState == voltha.AdminState_DISABLED {
 		logger.Debugln(ctx, "do-state-connected--device-admin-state-down")
 
-		cloned := proto.Clone(device).(*voltha.Device)
-		cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
-		cloned.OperStatus = voltha.OperStatus_UNKNOWN
-		dh.device = cloned
+		device.ConnectStatus = voltha.ConnectStatus_REACHABLE
+		device.OperStatus = voltha.OperStatus_UNKNOWN
+		dh.device = device
 
 		if err = dh.updateDeviceStateInCore(ctx, &ca.DeviceStateFilter{
-			DeviceId:   cloned.Id,
-			OperStatus: cloned.OperStatus,
-			ConnStatus: cloned.ConnectStatus,
+			DeviceId:   device.Id,
+			OperStatus: device.OperStatus,
+			ConnStatus: device.ConnectStatus,
 		}); err != nil {
 			return olterrors.NewErrAdapter("device-state-update-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
 		}
@@ -1804,7 +1801,7 @@
 		if st.Code() == codes.AlreadyExists {
 			logger.Debugw(ctx, "onu-activation-in-progress", log.Fields{"SerialNumber": serialNumber, "onu-id": onuID, "device-id": dh.device.Id})
 		} else {
-			return olterrors.NewErrAdapter("onu-activate-failed", log.Fields{"onu": Onu, "device-id": dh.device.Id}, err)
+			return olterrors.NewErrAdapter("onu-activate-failed", log.Fields{"onu-serial": serialNumber, "onu-id": onuID, "device-id": dh.device.Id}, err)
 		}
 	} else {
 		logger.Infow(ctx, "activated-onu", log.Fields{"SerialNumber": serialNumber, "device-id": dh.device.Id})
@@ -2491,13 +2488,12 @@
 	dh.lockDevice.RUnlock()
 
 	go dh.notifyChildDevices(ctx, "unreachable")
-	cloned := proto.Clone(device).(*voltha.Device)
 	// Update device Admin state
-	dh.device = cloned
+	dh.device = device
 
 	// Update the all pon ports state on that device to disable and NNI remains active as NNI remains active in openolt agent.
 	if err := dh.updatePortsStateInCore(ctx, &ca.PortStateFilter{
-		DeviceId:       cloned.Id,
+		DeviceId:       device.Id,
 		PortTypeFilter: ^uint32(1 << voltha.Port_PON_OLT),
 		OperStatus:     voltha.OperStatus_UNKNOWN,
 	}); err != nil {
@@ -2524,7 +2520,7 @@
 				OnuIndication: &onuInd,
 			})
 			if err != nil {
-				logger.Errorw(ctx, "failed-to-send-inter-adapter-message", log.Fields{"OnuInd": onuInd,
+				logger.Errorw(ctx, "failed-to-send-inter-adapter-message", log.Fields{"OnuInd": onuInd.String(),
 					"From Adapter": dh.openOLT.config.AdapterEndpoint, "DeviceType": onuDevice.Type, "device-id": onuDevice.Id})
 			}
 		}
@@ -2801,7 +2797,7 @@
 func (dh *DeviceHandler) handlePacketIndication(ctx context.Context, packetIn *oop.PacketIndication) error {
 	if logger.V(log.DebugLevel) {
 		logger.Debugw(ctx, "received-packet-in", log.Fields{
-			"packet-indication": *packetIn,
+			"packet-indication": packetIn.String(),
 			"device-id":         dh.device.Id,
 			"packet":            hex.EncodeToString(packetIn.Pkt),
 		})
@@ -2856,7 +2852,7 @@
 
 	if logger.V(log.DebugLevel) {
 		logger.Debugw(ctx, "sending-packet-to-nni", log.Fields{
-			"uplink-pkt": uplinkPkt,
+			"uplink-pkt": uplinkPkt.String(),
 			"packet":     hex.EncodeToString(packet.Data),
 			"device-id":  dh.device.Id,
 		})
@@ -3091,11 +3087,10 @@
 
 		// raise olt communication failure event
 		raisedTs := time.Now().Unix()
-		cloned := proto.Clone(device).(*voltha.Device)
-		cloned.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
-		cloned.OperStatus = voltha.OperStatus_UNKNOWN
-		dh.device = cloned // update local copy of the device
-		go dh.eventMgr.oltCommunicationEvent(ctx, cloned, raisedTs)
+		device.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
+		device.OperStatus = voltha.OperStatus_UNKNOWN
+		dh.device = device // update local copy of the device
+		go dh.eventMgr.oltCommunicationEvent(ctx, device, raisedTs)
 
 		dh.lockDevice.RLock()
 		// Stop the Stats collector
@@ -3163,11 +3158,10 @@
 
 	//raise olt communication failure event
 	raisedTs := time.Now().Unix()
-	cloned := proto.Clone(device).(*voltha.Device)
-	cloned.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
-	cloned.OperStatus = voltha.OperStatus_UNKNOWN
-	dh.device = cloned // update local copy of the device
-	go dh.eventMgr.oltCommunicationEvent(ctx, cloned, raisedTs)
+	device.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
+	device.OperStatus = voltha.OperStatus_UNKNOWN
+	dh.device = device // update local copy of the device
+	go dh.eventMgr.oltCommunicationEvent(ctx, device, raisedTs)
 
 	if err := dh.cleanupDeviceResources(ctx); err != nil {
 		logger.Errorw(ctx, "failure-in-cleanup-device-resources", log.Fields{"device-id": dh.device.Id, "err": err})
@@ -3713,9 +3707,9 @@
 		select {
 		// process one indication per onu, before proceeding to the next one
 		case onuInd := <-onuChannels.indicationChannel:
-			indication := *(proto.Clone(onuInd.indication)).(*oop.Indication)
+			indication := onuInd.indication
 			logger.Debugw(onuInd.ctx, "calling-indication", log.Fields{"device-id": dh.device.Id,
-				"ind": indication})
+				"ind": indication.String()})
 			switch indication.Data.(type) {
 			case *oop.Indication_OnuInd:
 				if err := dh.onuIndication(onuInd.ctx, indication.GetOnuInd()); err != nil {
@@ -4183,7 +4177,7 @@
 	rxPower, err := dh.Client.GetPonRxPower(subCtx, &Onu)
 	cancel()
 	if err != nil {
-		logger.Errorw(ctx, "error-while-getting-rx-power", log.Fields{"Onu": Onu, "err": err})
+		logger.Errorw(ctx, "error-while-getting-rx-power", log.Fields{"intf-id": Onu.IntfId, "onu-id": Onu.OnuId, "err": err})
 		return generateSingleGetValueErrorResponse(err)
 	}
 	return &extension.SingleGetValueResponse{
@@ -4246,7 +4240,7 @@
 			rxPower, err := dh.Client.GetPonRxPower(subCtx, &Onu)
 			cancel()
 			if err != nil {
-				logger.Errorw(ctx, "error-while-getting-rx-power", log.Fields{"Onu": Onu, "err": err})
+				logger.Errorw(ctx, "error-while-getting-rx-power", log.Fields{"intf-id": Onu.IntfId, "onu-id": Onu.OnuId, "err": err})
 				return generateSingleGetValueErrorResponse(err)
 			}
 
@@ -4269,7 +4263,7 @@
 				rxPower, err := dh.Client.GetPonRxPower(subCtx, &Onu)
 				cancel()
 				if err != nil {
-					logger.Errorw(ctx, "error-while-getting-rx-power, however considering to proceed further with other ONUs on PON", log.Fields{"Onu": Onu, "err": err})
+					logger.Errorw(ctx, "error-while-getting-rx-power, however considering to proceed further with other ONUs on PON", log.Fields{"intf-id": Onu.IntfId, "onu-id": Onu.OnuId, "err": err})
 				} else {
 					rxPowerValue := extension.RxPower{}
 					rxPowerValue.OnuSn = onuInCache.(*OnuDevice).serialNumber
@@ -4280,11 +4274,11 @@
 					resp.Response.GetOltRxPower().RxPower = append(resp.Response.GetOltRxPower().RxPower, &rxPowerValue)
 				}
 			}
-			logger.Infow(ctx, "getPONRxPower response ", log.Fields{"Response": resp})
+			logger.Infow(ctx, "getPONRxPower response ", log.Fields{"status": resp.Response.Status})
 			return true
 		})
 	}
-	logger.Infow(ctx, "getPONRxPower response ", log.Fields{"Response": resp})
+	logger.Infow(ctx, "getPONRxPower response ", log.Fields{"status": resp.Response.Status})
 	return &resp
 }
 
@@ -4337,7 +4331,7 @@
 	ponPortStats.PonPort = uint32(portNumber)
 	ponPortStats.PortStatistics = ponStats
 
-	logger.Infow(ctx, "getPonPortStats response ", log.Fields{"Response": resp})
+	logger.Infow(ctx, "getPonPortStats response ", log.Fields{"status": resp.Response.Status, "pon-port": portNumber})
 	return &resp
 }
 
@@ -4390,7 +4384,7 @@
 	nniPortStats.NniPort = uint32(portNumber)
 	nniPortStats.PortStatistics = nniStats
 
-	logger.Infow(ctx, "getNniPortStats response ", log.Fields{"Response": resp})
+	logger.Infow(ctx, "getNniPortStats response ", log.Fields{"status": resp.Response.Status, "nni-port": portNumber})
 	return &resp
 }
 
diff --git a/internal/pkg/core/device_handler_test.go b/internal/pkg/core/device_handler_test.go
index 6f670e0..b4274c9 100644
--- a/internal/pkg/core/device_handler_test.go
+++ b/internal/pkg/core/device_handler_test.go
@@ -26,10 +26,9 @@
 	"time"
 
 	conf "github.com/opencord/voltha-lib-go/v7/pkg/config"
-	vgrpc "github.com/opencord/voltha-lib-go/v7/pkg/grpc"
-
 	"github.com/opencord/voltha-lib-go/v7/pkg/db"
 	fu "github.com/opencord/voltha-lib-go/v7/pkg/flows"
+	vgrpc "github.com/opencord/voltha-lib-go/v7/pkg/grpc"
 	plt "github.com/opencord/voltha-lib-go/v7/pkg/platform"
 	"github.com/opencord/voltha-lib-go/v7/pkg/pmmetrics"
 	ponrmgr "github.com/opencord/voltha-lib-go/v7/pkg/ponresourcemanager"
@@ -37,6 +36,7 @@
 	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
 	"github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
 	"github.com/opencord/voltha-openolt-adapter/pkg/mocks"
+	"github.com/opencord/voltha-protos/v5/go/adapter_service"
 	cmn "github.com/opencord/voltha-protos/v5/go/common"
 	ia "github.com/opencord/voltha-protos/v5/go/inter_adapter"
 	of "github.com/opencord/voltha-protos/v5/go/openflow_13"
@@ -168,7 +168,14 @@
 	cm := &conf.ConfigManager{}
 	cm.Backend = &db.Backend{StoreType: "etcd", Client: &mocks.MockKVClient{}}
 	cfg := &config.AdapterFlags{OmccEncryption: true}
-	openOLT := &OpenOLT{eventProxy: ep, config: cfg, KVStoreType: "etcd", KVStoreAddress: "1:2"}
+	openOLT := &OpenOLT{
+		UnimplementedAdapterServiceServer: adapter_service.UnimplementedAdapterServiceServer{},
+		eventProxy:                        ep,
+		config:                            cfg,
+		KVStoreType:                       "etcd",
+		KVStoreAddress:                    "1:2",
+	}
+
 	dh := NewDeviceHandler(cc, ep, device, openOLT, cm, cfg)
 	dh.kvStore = cm.Backend
 	oopRanges := []*oop.DeviceInfo_DeviceResourceRanges{{
diff --git a/internal/pkg/core/openolt.go b/internal/pkg/core/openolt.go
index ddd331f..0dd2325 100644
--- a/internal/pkg/core/openolt.go
+++ b/internal/pkg/core/openolt.go
@@ -23,7 +23,6 @@
 	"sync"
 	"time"
 
-	"github.com/golang/protobuf/ptypes/empty"
 	conf "github.com/opencord/voltha-lib-go/v7/pkg/config"
 	"github.com/opencord/voltha-lib-go/v7/pkg/events/eventif"
 	vgrpc "github.com/opencord/voltha-lib-go/v7/pkg/grpc"
@@ -40,10 +39,12 @@
 	"github.com/opencord/voltha-protos/v5/go/voltha"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/emptypb"
 )
 
 // OpenOLT structure holds the OLT information
 type OpenOLT struct {
+	adapter_service.UnimplementedAdapterServiceServer
 	eventProxy                         eventif.EventProxy
 	configManager                      *conf.ConfigManager
 	deviceHandlers                     map[string]*DeviceHandler
@@ -145,7 +146,7 @@
 }
 
 // AdoptDevice creates a new device handler if not present already and then adopts the device
-func (oo *OpenOLT) AdoptDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) AdoptDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	if device == nil {
 		return nil, olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil).Log()
 	}
@@ -156,7 +157,7 @@
 		oo.addDeviceHandlerToMap(handler)
 		go handler.AdoptDevice(log.WithSpanFromContext(context.Background(), ctx), device)
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // GetOfpDeviceInfo returns OFP information for the given device
@@ -169,7 +170,7 @@
 }
 
 // ReconcileDevice unimplemented
-func (oo *OpenOLT) ReconcileDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) ReconcileDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	if device == nil {
 		return nil, olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
 	}
@@ -229,49 +230,49 @@
 		go handler.transitionMap.Handle(dhCtx, DeviceInit)
 	} else {
 		logger.Warnf(ctx, "device-already-reconciled-or-active", log.Fields{"device-id": device.Id})
-		return &empty.Empty{}, status.Errorf(codes.AlreadyExists, "handler exists: %s", device.Id)
+		return &emptypb.Empty{}, status.Errorf(codes.AlreadyExists, "handler exists: %s", device.Id)
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // DisableDevice disables the given device
-func (oo *OpenOLT) DisableDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) DisableDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "disable-device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
 		if err := handler.DisableDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
 }
 
 // ReEnableDevice enables the olt device after disable
-func (oo *OpenOLT) ReEnableDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) ReEnableDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "reenable-device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
 		if err := handler.ReenableDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
 }
 
 // RebootDevice reboots the given device
-func (oo *OpenOLT) RebootDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) RebootDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "reboot-device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
 		if err := handler.RebootDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
 }
 
 // DeleteDevice deletes a device
-func (oo *OpenOLT) DeleteDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) DeleteDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "delete-device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
 		if err := handler.DeleteDevice(log.WithSpanFromContext(context.Background(), ctx), device); err != nil {
@@ -291,13 +292,13 @@
 				if !handler.isHeartbeatCheckActive && !handler.isCollectorActive && !handler.isReadIndicationRoutineActive {
 					logger.Debugf(ctx, "delete-device-handler")
 					oo.deleteDeviceHandlerToMap(handler)
-					return &empty.Empty{}, nil
+					return &emptypb.Empty{}, nil
 				}
 			case <-timeout:
 				// Timeout exceeded
 				logger.Warnw(ctx, "delete-device-handler timeout exceeded", log.Fields{"device-id": device.Id})
 				oo.deleteDeviceHandlerToMap(handler) // Clean up anyway
-				return &empty.Empty{}, nil
+				return &emptypb.Empty{}, nil
 			}
 		}
 	}
@@ -305,55 +306,55 @@
 }
 
 // UpdateFlowsIncrementally updates (add/remove) the flows on a given device
-func (oo *OpenOLT) UpdateFlowsIncrementally(ctx context.Context, incrFlows *ca.IncrementalFlows) (*empty.Empty, error) {
+func (oo *OpenOLT) UpdateFlowsIncrementally(ctx context.Context, incrFlows *ca.IncrementalFlows) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "update_flows_incrementally", log.Fields{"device-id": incrFlows.Device.Id, "flows": incrFlows.Flows, "flowMetadata": incrFlows.FlowMetadata})
 	if handler := oo.getDeviceHandler(incrFlows.Device.Id); handler != nil {
 		if err := handler.UpdateFlowsIncrementally(log.WithSpanFromContext(context.Background(), ctx), incrFlows.Device, incrFlows.Flows, incrFlows.Groups, incrFlows.FlowMetadata); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": incrFlows.Device.Id}, nil)
 }
 
 // UpdatePmConfig returns PmConfigs nil or error
-func (oo *OpenOLT) UpdatePmConfig(ctx context.Context, configs *ca.PmConfigsInfo) (*empty.Empty, error) {
+func (oo *OpenOLT) UpdatePmConfig(ctx context.Context, configs *ca.PmConfigsInfo) (*emptypb.Empty, error) {
 	logger.Debugw(ctx, "update_pm_config", log.Fields{"device-id": configs.DeviceId, "pm-configs": configs.PmConfigs})
 	if handler := oo.getDeviceHandler(configs.DeviceId); handler != nil {
 		handler.UpdatePmConfig(log.WithSpanFromContext(context.Background(), ctx), configs.PmConfigs)
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": configs.DeviceId}, nil)
 }
 
 // SendPacketOut sends packet out to the device
-func (oo *OpenOLT) SendPacketOut(ctx context.Context, packet *ca.PacketOut) (*empty.Empty, error) {
+func (oo *OpenOLT) SendPacketOut(ctx context.Context, packet *ca.PacketOut) (*emptypb.Empty, error) {
 	logger.Debugw(ctx, "send_packet_out", log.Fields{"device-id": packet.DeviceId, "egress_port_no": packet.EgressPortNo, "pkt": packet.Packet})
 	if handler := oo.getDeviceHandler(packet.DeviceId); handler != nil {
 		if err := handler.PacketOut(log.WithSpanFromContext(context.Background(), ctx), packet.EgressPortNo, packet.Packet); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": packet.DeviceId}, nil)
 }
 
 // EnableOnuSerialNumber to Enable onu serial number
-func (oo *OpenOLT) EnableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+func (oo *OpenOLT) EnableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "enable_onu_serial_number", log.Fields{"olt_device_id": device.OltDeviceId, "onu_serial_number": device.SerialNumber})
 	if err := oo.enableDisableOnuSerialNumber(log.WithSpanFromContext(context.Background(), ctx), device, true); err != nil {
 		return nil, err
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // DisableOnuSerialNumber to Disable onu serial number
-func (oo *OpenOLT) DisableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+func (oo *OpenOLT) DisableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "disable_onu_serial_number", log.Fields{"olt_device_id": device.OltDeviceId, "onu_serial_number": device.SerialNumber})
 	if err := oo.enableDisableOnuSerialNumber(log.WithSpanFromContext(context.Background(), ctx), device, false); err != nil {
 		return nil, err
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // enableDisableOnuSerialNumber to Disable onu or Enable onu
@@ -389,21 +390,21 @@
 }
 
 // EnableOnuDevice to Enable onu
-func (oo *OpenOLT) EnableOnuDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) EnableOnuDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "enable_onu", log.Fields{"onu_device_id": device.Id, "onu_serial_number": device.SerialNumber})
 	if err := oo.enableDisableOnuDevice(log.WithSpanFromContext(context.Background(), ctx), device, true); err != nil {
 		return nil, err
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // DisableOnuDevice to Disable onu
-func (oo *OpenOLT) DisableOnuDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) DisableOnuDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "disable_onu", log.Fields{"onu_device_id": device.Id, "onu_serial_number": device.SerialNumber})
 	if err := oo.enableDisableOnuDevice(log.WithSpanFromContext(context.Background(), ctx), device, false); err != nil {
 		return nil, err
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // enableDisableOnuDevice to Disable onu or Enable onu
@@ -434,21 +435,21 @@
 }
 
 // EnablePort to Enable PON/NNI interface
-func (oo *OpenOLT) EnablePort(ctx context.Context, port *voltha.Port) (*empty.Empty, error) {
+func (oo *OpenOLT) EnablePort(ctx context.Context, port *voltha.Port) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "enable_port", log.Fields{"device-id": port.DeviceId, "port": port})
 	if err := oo.enableDisablePort(log.WithSpanFromContext(context.Background(), ctx), port.DeviceId, port, true); err != nil {
 		return nil, err
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // DisablePort to Disable pon/nni interface
-func (oo *OpenOLT) DisablePort(ctx context.Context, port *voltha.Port) (*empty.Empty, error) {
+func (oo *OpenOLT) DisablePort(ctx context.Context, port *voltha.Port) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "disable_port", log.Fields{"device-id": port.DeviceId, "port": port})
 	if err := oo.enableDisablePort(log.WithSpanFromContext(context.Background(), ctx), port.DeviceId, port, false); err != nil {
 		return nil, err
 	}
-	return &empty.Empty{}, nil
+	return &emptypb.Empty{}, nil
 }
 
 // enableDisablePort to Disable pon or Enable PON interface
@@ -476,13 +477,13 @@
 }
 
 // ChildDeviceLost deletes the ONU and its references from PONResources
-func (oo *OpenOLT) ChildDeviceLost(ctx context.Context, childDevice *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) ChildDeviceLost(ctx context.Context, childDevice *voltha.Device) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "Child-device-lost", log.Fields{"parent-device-id": childDevice.ParentId, "child-device-id": childDevice.Id})
 	if handler := oo.getDeviceHandler(childDevice.ParentId); handler != nil {
 		if err := handler.ChildDeviceLost(log.WithSpanFromContext(context.Background(), ctx), childDevice.ParentPortNo, childDevice.ProxyAddress.OnuId, childDevice.SerialNumber); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"parent-device-id": childDevice.ParentId}, nil).Log()
 }
@@ -602,25 +603,25 @@
  */
 
 // ProxyOmciRequests proxies an onu sw download OMCI request from the child adapter
-func (oo *OpenOLT) ProxyOmciRequests(ctx context.Context, request *ia.OmciMessages) (*empty.Empty, error) {
+func (oo *OpenOLT) ProxyOmciRequests(ctx context.Context, request *ia.OmciMessages) (*emptypb.Empty, error) {
 	if handler := oo.getDeviceHandler(request.ParentDeviceId); handler != nil {
 		if err := handler.ProxyOmciRequests(ctx, request); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("no-device-handler", log.Fields{"parent-device-id": request.ParentDeviceId, "child-device-id": request.ChildDeviceId}, nil).Log()
 }
 
 // ProxyOmciRequest proxies an OMCI request from the child adapter
-func (oo *OpenOLT) ProxyOmciRequest(ctx context.Context, request *ia.OmciMessage) (*empty.Empty, error) {
+func (oo *OpenOLT) ProxyOmciRequest(ctx context.Context, request *ia.OmciMessage) (*emptypb.Empty, error) {
 	logger.Debugw(ctx, "proxy-omci-request", log.Fields{"request": request})
 
 	if handler := oo.getDeviceHandler(request.ParentDeviceId); handler != nil {
 		if err := handler.ProxyOmciMessage(ctx, request); err != nil {
 			return nil, err
 		}
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 	return nil, olterrors.NewErrNotFound("no-device-handler", log.Fields{"parent-device-id": request.ParentDeviceId, "child-device-id": request.ChildDeviceId}, nil).Log()
 }
@@ -684,7 +685,7 @@
 }
 
 // UpdateDevice updates the address of the OLT for now
-func (oo *OpenOLT) UpdateDevice(ctx context.Context, updateDeviceReq *voltha.UpdateDevice) (*empty.Empty, error) {
+func (oo *OpenOLT) UpdateDevice(ctx context.Context, updateDeviceReq *voltha.UpdateDevice) (*emptypb.Empty, error) {
 	logger.Infow(ctx, "update-device", log.Fields{"device": updateDeviceReq})
 	if updateDeviceReq == nil {
 		return nil, fmt.Errorf("nil-device-config")
@@ -694,7 +695,7 @@
 	}
 	if handler := oo.getDeviceHandler(updateDeviceReq.Id); handler != nil {
 		go handler.UpdateDevice(context.Background(), updateDeviceReq)
-		return &empty.Empty{}, nil
+		return &emptypb.Empty{}, nil
 	}
 
 	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": updateDeviceReq.Id}, nil).Log()
@@ -712,7 +713,7 @@
 }
 
 // SetExtValue is unimplemented
-func (oo *OpenOLT) SetExtValue(context.Context, *ca.SetExtValueMessage) (*empty.Empty, error) {
+func (oo *OpenOLT) SetExtValue(context.Context, *ca.SetExtValueMessage) (*emptypb.Empty, error) {
 	return nil, olterrors.ErrNotImplemented
 }
 
@@ -722,12 +723,12 @@
 }
 
 // SuppressEvent unimplemented
-func (oo *OpenOLT) SuppressEvent(ctx context.Context, filter *voltha.EventFilter) (*empty.Empty, error) {
+func (oo *OpenOLT) SuppressEvent(ctx context.Context, filter *voltha.EventFilter) (*emptypb.Empty, error) {
 	return nil, olterrors.ErrNotImplemented
 }
 
 // UnSuppressEvent  unimplemented
-func (oo *OpenOLT) UnSuppressEvent(ctx context.Context, filter *voltha.EventFilter) (*empty.Empty, error) {
+func (oo *OpenOLT) UnSuppressEvent(ctx context.Context, filter *voltha.EventFilter) (*emptypb.Empty, error) {
 	return nil, olterrors.ErrNotImplemented
 }
 
@@ -787,11 +788,11 @@
 }
 
 // UpdateFlowsBulk is unimplemented
-func (oo *OpenOLT) UpdateFlowsBulk(ctx context.Context, flows *ca.BulkFlows) (*empty.Empty, error) {
+func (oo *OpenOLT) UpdateFlowsBulk(ctx context.Context, flows *ca.BulkFlows) (*emptypb.Empty, error) {
 	return nil, olterrors.ErrNotImplemented
 }
 
 // SelfTestDevice unimplemented
-func (oo *OpenOLT) SelfTestDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+func (oo *OpenOLT) SelfTestDevice(ctx context.Context, device *voltha.Device) (*emptypb.Empty, error) {
 	return nil, olterrors.ErrNotImplemented
 }
diff --git a/internal/pkg/core/openoltInterAdapter.go b/internal/pkg/core/openoltInterAdapter.go
index d27f600..84c6dd2 100644
--- a/internal/pkg/core/openoltInterAdapter.go
+++ b/internal/pkg/core/openoltInterAdapter.go
@@ -22,16 +22,17 @@
 	"fmt"
 	"time"
 
-	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/opencord/voltha-lib-go/v7/pkg/log"
 	"github.com/opencord/voltha-protos/v5/go/common"
 	"github.com/opencord/voltha-protos/v5/go/health"
 	ia "github.com/opencord/voltha-protos/v5/go/inter_adapter"
 	oltia "github.com/opencord/voltha-protos/v5/go/olt_inter_adapter_service"
+	"google.golang.org/protobuf/types/known/emptypb"
 )
 
 // OpenOLTInterAdapter structure holds a reference to the oltAdapter
 type OpenOLTInterAdapter struct {
+	oltia.UnimplementedOltInterAdapterServiceServer
 	oltAdapter  *OpenOLT
 	exitChannel chan struct{}
 }
@@ -53,12 +54,12 @@
 }
 
 // ProxyOmciRequest proxies an OMCI request from the child adapter
-func (oo *OpenOLTInterAdapter) ProxyOmciRequest(ctx context.Context, request *ia.OmciMessage) (*empty.Empty, error) {
+func (oo *OpenOLTInterAdapter) ProxyOmciRequest(ctx context.Context, request *ia.OmciMessage) (*emptypb.Empty, error) {
 	return oo.oltAdapter.ProxyOmciRequest(ctx, request)
 }
 
 // ProxyOmciRequests proxies an OMCI request from the child adapter
-func (oo *OpenOLTInterAdapter) ProxyOmciRequests(ctx context.Context, request *ia.OmciMessages) (*empty.Empty, error) {
+func (oo *OpenOLTInterAdapter) ProxyOmciRequests(ctx context.Context, request *ia.OmciMessages) (*emptypb.Empty, error) {
 	return oo.oltAdapter.ProxyOmciRequests(ctx, request)
 }
 
diff --git a/internal/pkg/core/openolt_flowmgr.go b/internal/pkg/core/openolt_flowmgr.go
index 134b095..958ab19 100644
--- a/internal/pkg/core/openolt_flowmgr.go
+++ b/internal/pkg/core/openolt_flowmgr.go
@@ -395,8 +395,9 @@
 	case tp_pb.Direction_DOWNSTREAM:
 		SchedCfg = f.techprofile.GetDsScheduler(sq.tpInst.(*tp_pb.TechProfileInstance))
 	}
-	TrafficSched := []*tp_pb.TrafficScheduler{f.techprofile.GetTrafficScheduler(sq.tpInst.(*tp_pb.TechProfileInstance), SchedCfg, TrafficShaping)}
-	TrafficSched[0].TechProfileId = sq.tpID
+	trafficSched := f.techprofile.GetTrafficScheduler(sq.tpInst.(*tp_pb.TechProfileInstance), SchedCfg, TrafficShaping)
+	trafficSched.TechProfileId = sq.tpID
+	TrafficSched := []*tp_pb.TrafficScheduler{trafficSched}
 
 	/* Lets make a simple assumption that if the meter-id is present on the KV store,
 	 * then the scheduler and queues configuration is applied on the OLT device
@@ -689,8 +690,9 @@
 
 	TrafficShaping := &tp_pb.TrafficShapingInfo{} // this info is not really useful for the agent during flow removal. Just use default values.
 
-	TrafficSched := []*tp_pb.TrafficScheduler{f.techprofile.GetTrafficScheduler(sq.tpInst.(*tp_pb.TechProfileInstance), SchedCfg, TrafficShaping)}
-	TrafficSched[0].TechProfileId = sq.tpID
+	trafficSched := f.techprofile.GetTrafficScheduler(sq.tpInst.(*tp_pb.TechProfileInstance), SchedCfg, TrafficShaping)
+	trafficSched.TechProfileId = sq.tpID
+	TrafficSched := []*tp_pb.TrafficScheduler{trafficSched}
 
 	subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), f.deviceHandler.cfg.RPCTimeout)
 	if _, err = f.deviceHandler.Client.RemoveTrafficSchedulers(subCtx, &tp_pb.TrafficSchedulers{
@@ -759,8 +761,9 @@
 	}
 
 	TrafficShaping := &tp_pb.TrafficShapingInfo{} // this info is not really useful for the agent during flow removal. Just use default values.
-	TrafficSched := []*tp_pb.TrafficScheduler{f.techprofile.GetTrafficScheduler(sq.tpInst.(*tp_pb.TechProfileInstance), schedCfg, TrafficShaping)}
-	TrafficSched[0].TechProfileId = sq.tpID
+	trafficSched := f.techprofile.GetTrafficScheduler(sq.tpInst.(*tp_pb.TechProfileInstance), schedCfg, TrafficShaping)
+	trafficSched.TechProfileId = sq.tpID
+	TrafficSched := []*tp_pb.TrafficScheduler{trafficSched}
 
 	// Remove traffic queues. Ignore any errors, just log them.
 	if TrafficQueues, err := f.techprofile.GetTrafficQueues(ctx, sq.tpInst.(*tp_pb.TechProfileInstance), sq.direction); err != nil {
@@ -1074,16 +1077,16 @@
 	logicalFlow := flowContext.logicalFlow
 	logger.Infow(ctx, "adding-hsia-flow",
 		log.Fields{
-			"intf-id":     intfID,
-			"onu-id":      onuID,
-			"uni-id":      uniID,
-			"device-id":   f.deviceHandler.device.Id,
-			"classifier":  classifier,
-			"action":      action,
-			"direction":   direction,
-			"alloc-id":    allocID,
-			"gemport-id":  gemPortID,
-			"logicalflow": *logicalFlow})
+			"intf-id":    intfID,
+			"onu-id":     onuID,
+			"uni-id":     uniID,
+			"device-id":  f.deviceHandler.device.Id,
+			"classifier": classifier,
+			"action":     action,
+			"direction":  direction,
+			"alloc-id":   allocID,
+			"gemport-id": gemPortID,
+			"flow-id":    logicalFlow.Id})
 
 	present, err := f.resourceMgr.IsFlowOnKvStore(ctx, int32(onuID), logicalFlow.Id)
 	if present {
@@ -1105,7 +1108,7 @@
 	}
 	logger.Debugw(ctx, "created-classifier-proto",
 		log.Fields{
-			"classifier": *classifierProto,
+			"classifier": classifierProto.String(),
 			"device-id":  f.deviceHandler.device.Id})
 	actionProto, err := makeOpenOltActionField(action, classifier)
 	if err != nil {
@@ -1113,7 +1116,7 @@
 	}
 	logger.Debugw(ctx, "created-action-proto",
 		log.Fields{
-			"action":    *actionProto,
+			"action":    actionProto.String(),
 			"device-id": f.deviceHandler.device.Id})
 	networkIntfID, err := getNniIntfID(ctx, classifier, action)
 	if err != nil {
@@ -1149,7 +1152,7 @@
 	logger.Infow(ctx, "hsia-flow-added-to-device-successfully",
 		log.Fields{"direction": direction,
 			"device-id": f.deviceHandler.device.Id,
-			"flow":      flow,
+			"flow-id":   flow.FlowId,
 			"intf-id":   intfID,
 			"onu-id":    onuID})
 
@@ -1210,7 +1213,7 @@
 	if err != nil {
 		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier}, err).Log()
 	}
-	logger.Debugw(ctx, "created-classifier-proto", log.Fields{"classifier": *classifierProto})
+	logger.Debugw(ctx, "created-classifier-proto", log.Fields{"classifier": classifierProto.String()})
 	actionProto, err := makeOpenOltActionField(action, classifier)
 	if err != nil {
 		return olterrors.NewErrInvalidValue(log.Fields{"action": action}, err).Log()
@@ -1235,7 +1238,7 @@
 		GemportToAes:  flowContext.gemToAes,
 	}
 	if err := f.addFlowToDevice(ctx, logicalFlow, &dhcpFlow); err != nil {
-		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"dhcp-flow": dhcpFlow}, err).Log()
+		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"dhcp-flow-id": dhcpFlow.FlowId}, err).Log()
 	}
 	logger.Infow(ctx, "dhcp-ul-flow-added-to-device-successfully",
 		log.Fields{
@@ -1305,7 +1308,7 @@
 	}
 	logger.Debugw(ctx, "created-classifier-proto",
 		log.Fields{
-			"classifier": *classifierProto,
+			"classifier": classifierProto.String(),
 			"device-id":  f.deviceHandler.device.Id})
 	actionProto, err := makeOpenOltActionField(action, classifier)
 	if err != nil {
@@ -1332,7 +1335,7 @@
 	}
 
 	if err := f.addFlowToDevice(ctx, logicalFlow, &flow); err != nil {
-		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow": flow, "device-id": f.deviceHandler.device.Id}, err).Log()
+		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow-id": flow.FlowId, "device-id": f.deviceHandler.device.Id}, err).Log()
 	}
 
 	return nil
@@ -1402,7 +1405,7 @@
 	}
 	logger.Debugw(ctx, "created-classifier-proto",
 		log.Fields{
-			"classifier": *classifierProto,
+			"classifier": classifierProto.String(),
 			"device-id":  f.deviceHandler.device.Id})
 	actionProto, err := makeOpenOltActionField(uplinkAction, uplinkClassifier)
 	if err != nil {
@@ -1410,7 +1413,7 @@
 	}
 	logger.Debugw(ctx, "created-action-proto",
 		log.Fields{
-			"action":    *actionProto,
+			"action":    actionProto.String(),
 			"device-id": f.deviceHandler.device.Id})
 	networkIntfID, err := getNniIntfID(ctx, classifier, action)
 	if err != nil {
@@ -1440,7 +1443,7 @@
 		GemportToAes:  flowContext.gemToAes,
 	}
 	if err := f.addFlowToDevice(ctx, logicalFlow, &upstreamFlow); err != nil {
-		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow": upstreamFlow}, err).Log()
+		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow-id": upstreamFlow.FlowId}, err).Log()
 	}
 	logger.Infow(ctx, "ethType-ul-flow-added-to-device-successfully",
 		log.Fields{
@@ -1640,7 +1643,7 @@
 	}
 
 	logger.Debugw(ctx, "sending-flow-to-device-via-grpc", log.Fields{
-		"flow":      *deviceFlow,
+		"flow-id":   deviceFlow.FlowId,
 		"device-id": f.deviceHandler.device.Id,
 		"intf-id":   intfID})
 	subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), f.deviceHandler.cfg.RPCTimeout)
@@ -1650,24 +1653,24 @@
 	st, _ := status.FromError(err)
 	if st.Code() == codes.AlreadyExists {
 		logger.Debug(ctx, "flow-already-exists", log.Fields{
-			"err":        err,
-			"deviceFlow": deviceFlow,
-			"device-id":  f.deviceHandler.device.Id,
-			"intf-id":    intfID})
+			"err":       err,
+			"flow-id":   deviceFlow.FlowId,
+			"device-id": f.deviceHandler.device.Id,
+			"intf-id":   intfID})
 		return nil
 	}
 
 	if err != nil {
 		logger.Errorw(ctx, "failed-to-add-flow-to-device",
 			log.Fields{"err": err,
-				"device-flow": deviceFlow,
-				"device-id":   f.deviceHandler.device.Id,
-				"intf-id":     intfID})
+				"flow-id":   deviceFlow.FlowId,
+				"device-id": f.deviceHandler.device.Id,
+				"intf-id":   intfID})
 		return err
 	}
 	logger.Infow(ctx, "flow-added-to-device-successfully ",
 		log.Fields{
-			"flow":      *deviceFlow,
+			"flow-id":   deviceFlow.FlowId,
 			"device-id": f.deviceHandler.device.Id,
 			"intf-id":   intfID})
 
@@ -1681,7 +1684,7 @@
 func (f *OpenOltFlowMgr) removeFlowFromDevice(ctx context.Context, deviceFlow *openoltpb2.Flow, ofFlowID uint64) error {
 	logger.Debugw(ctx, "sending-flow-to-device-via-grpc",
 		log.Fields{
-			"flow":      *deviceFlow,
+			"flow-id":   deviceFlow.FlowId,
 			"device-id": f.deviceHandler.device.Id})
 	subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), f.deviceHandler.cfg.RPCTimeout)
 	_, err := f.deviceHandler.Client.FlowRemove(subCtx, deviceFlow)
@@ -1700,7 +1703,7 @@
 	}
 	logger.Infow(ctx, "flow-removed-from-device-successfully", log.Fields{
 		"of-flow-id": ofFlowID,
-		"flow":       *deviceFlow,
+		"flow-id":    deviceFlow.FlowId,
 		"device-id":  f.deviceHandler.device.Id,
 	})
 	return nil
@@ -1753,7 +1756,7 @@
 	}
 	logger.Debugw(ctx, "created-classifier-proto",
 		log.Fields{
-			"classifier": *classifierProto,
+			"classifier": classifierProto.String(),
 			"device-id":  f.deviceHandler.device.Id})
 	actionProto, err := makeOpenOltActionField(actionInfo, classifierInfo)
 	if err != nil {
@@ -1764,7 +1767,7 @@
 	}
 	logger.Debugw(ctx, "created-action-proto",
 		log.Fields{
-			"action":    *actionProto,
+			"action":    actionProto.String(),
 			"device-id": f.deviceHandler.device.Id})
 
 	downstreamflow := openoltpb2.Flow{AccessIntfId: int32(-1), // AccessIntfId not required
@@ -1782,7 +1785,7 @@
 	if err := f.addFlowToDevice(ctx, flow, &downstreamflow); err != nil {
 		return olterrors.NewErrFlowOp("add", flow.Id,
 			log.Fields{
-				"flow":      downstreamflow,
+				"flow-id":   downstreamflow.FlowId,
 				"device-id": f.deviceHandler.device.Id}, err)
 	}
 	logger.Infow(ctx, "lldp-trap-on-nni-flow-added-to-device-successfully",
@@ -1873,7 +1876,7 @@
 		TpInstancePath: tpPath,
 		GemPortId:      gemPortID,
 	}
-	logger.Debugw(ctx, "sending-gem-port-delete-to-openonu-adapter", log.Fields{"msg": *delGemPortMsg, "child-device-id": onuDev.deviceID})
+	logger.Debugw(ctx, "sending-gem-port-delete-to-openonu-adapter", log.Fields{"msg": delGemPortMsg.String(), "child-device-id": onuDev.deviceID})
 
 	if err := f.deviceHandler.sendDeleteGemPortToChildAdapter(ctx, onuDev.adapterEndpoint, delGemPortMsg); err != nil {
 		return olterrors.NewErrCommunication("send-delete-gem-port-to-onu-adapter",
@@ -1916,7 +1919,7 @@
 
 	logger.Debugw(ctx, "sending-tcont-delete-to-openonu-adapter",
 		log.Fields{
-			"msg":       *delTcontMsg,
+			"msg":       delTcontMsg.String(),
 			"device-id": f.deviceHandler.device.Id})
 
 	if err := f.deviceHandler.sendDeleteTContToChildAdapter(ctx, onuDev.adapterEndpoint, delTcontMsg); err != nil {
@@ -2131,7 +2134,7 @@
 	logger.Debugw(ctx, "clear-flow-from-resource-manager",
 		log.Fields{
 			"flowDirection": flowDirection,
-			"flow":          *flow,
+			"flow-id":       flow.Id,
 			"device-id":     f.deviceHandler.device.Id})
 
 	if flowDirection == Multicast {
@@ -2212,7 +2215,7 @@
 
 // RemoveFlow removes the flow from the device
 func (f *OpenOltFlowMgr) RemoveFlow(ctx context.Context, flow *ofp.OfpFlowStats) error {
-	logger.Debugw(ctx, "removing-flow", log.Fields{"flow": *flow})
+	logger.Debugw(ctx, "removing-flow", log.Fields{"flow-id": flow.Id})
 	var direction string
 	actionInfo := make(map[string]interface{})
 
@@ -2519,7 +2522,7 @@
 		Cookie:        flow.Cookie}
 
 	if err := f.addFlowToDevice(ctx, flow, &multicastFlow); err != nil {
-		return olterrors.NewErrFlowOp("add", flow.Id, log.Fields{"flow": multicastFlow}, err)
+		return olterrors.NewErrFlowOp("add", flow.Id, log.Fields{"flow-id": multicastFlow.FlowId}, err)
 	}
 	logger.Info(ctx, "multicast-flow-added-to-device-successfully")
 	// get cached group
@@ -2552,7 +2555,7 @@
 }
 
 // sendTPDownloadMsgToChild send payload
-func (f *OpenOltFlowMgr) sendTPDownloadMsgToChild(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, uni string, TpID uint32, tpInst tp_pb.TechProfileInstance) error {
+func (f *OpenOltFlowMgr) sendTPDownloadMsgToChild(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, uni string, TpID uint32, tpInst *tp_pb.TechProfileInstance) error {
 	onuDev, err := f.getOnuDevice(ctx, intfID, onuID)
 	if err != nil {
 		logger.Errorw(ctx, "couldnt-find-onu-child-device",
@@ -2569,9 +2572,9 @@
 		DeviceId:       onuDev.deviceID,
 		UniId:          uniID,
 		TpInstancePath: tpPath,
-		TechTpInstance: &ia.TechProfileDownloadMessage_TpInstance{TpInstance: &tpInst},
+		TechTpInstance: &ia.TechProfileDownloadMessage_TpInstance{TpInstance: tpInst},
 	}
-	logger.Debugw(ctx, "sending-load-tech-profile-request-to-brcm-onu-adapter", log.Fields{"tpDownloadMsg": *tpDownloadMsg})
+	logger.Debugw(ctx, "sending-load-tech-profile-request-to-brcm-onu-adapter", log.Fields{"tpDownloadMsg": tpDownloadMsg.String()})
 
 	err = f.deviceHandler.sendDownloadTechProfileToChildAdapter(ctx, onuDev.adapterEndpoint, tpDownloadMsg)
 	if err != nil {
@@ -2711,12 +2714,12 @@
 	if err != nil {
 		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier}, err)
 	}
-	logger.Debugw(ctx, "created-classifier-proto", log.Fields{"classifier": *classifierProto})
+	logger.Debugw(ctx, "created-classifier-proto", log.Fields{"classifier": classifierProto.String()})
 	actionProto, err := makeOpenOltActionField(action, classifier)
 	if err != nil {
 		return olterrors.NewErrInvalidValue(log.Fields{"action": action}, err)
 	}
-	logger.Debugw(ctx, "created-action-proto", log.Fields{"action": *actionProto})
+	logger.Debugw(ctx, "created-action-proto", log.Fields{"action": actionProto.String()})
 	downstreamflow := openoltpb2.Flow{AccessIntfId: int32(-1), // AccessIntfId not required
 		OnuId:         int32(onuID), // OnuId not required
 		UniId:         int32(uniID), // UniId not used
@@ -2731,7 +2734,7 @@
 		Cookie:        logicalFlow.Cookie,
 		PortNo:        portNo}
 	if err := f.addFlowToDevice(ctx, logicalFlow, &downstreamflow); err != nil {
-		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow": downstreamflow}, err)
+		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow-id": downstreamflow.FlowId}, err)
 	}
 	logger.Info(ctx, "trap-on-nni-flow-added–to-device-successfully")
 	return nil
@@ -2818,12 +2821,12 @@
 	if err != nil {
 		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier}, err)
 	}
-	logger.Debugw(ctx, "created-classifier-proto-for-the-igmp-flow", log.Fields{"classifier": *classifierProto})
+	logger.Debugw(ctx, "created-classifier-proto-for-the-igmp-flow", log.Fields{"classifier": classifierProto.String()})
 	actionProto, err := makeOpenOltActionField(action, classifier)
 	if err != nil {
 		return olterrors.NewErrInvalidValue(log.Fields{"action": action}, err)
 	}
-	logger.Debugw(ctx, "created-action-proto-for-the-igmp-flow", log.Fields{"action": *actionProto})
+	logger.Debugw(ctx, "created-action-proto-for-the-igmp-flow", log.Fields{"action": actionProto.String()})
 	downstreamflow := openoltpb2.Flow{AccessIntfId: int32(-1), // AccessIntfId not required
 		OnuId:         int32(onuID), // OnuId not required
 		UniId:         int32(uniID), // UniId not used
@@ -2838,7 +2841,7 @@
 		Cookie:        logicalFlow.Cookie,
 		PortNo:        portNo}
 	if err := f.addFlowToDevice(ctx, logicalFlow, &downstreamflow); err != nil {
-		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow": downstreamflow}, err)
+		return olterrors.NewErrFlowOp("add", logicalFlow.Id, log.Fields{"flow-id": downstreamflow.FlowId}, err)
 	}
 	logger.Info(ctx, "igmp-trap-on-nni-flow-added-to-device-successfully")
 
@@ -3032,7 +3035,7 @@
 	}
 	// Send Techprofile download event to child device in go routine as it takes time
 	go func() {
-		if err := f.sendTPDownloadMsgToChild(ctx, intfID, onuID, uniID, uni, tpID, *(TpInst.(*tp_pb.TechProfileInstance))); err != nil {
+		if err := f.sendTPDownloadMsgToChild(ctx, intfID, onuID, uniID, uni, tpID, TpInst.(*tp_pb.TechProfileInstance)); err != nil {
 			logger.Warn(ctx, err)
 		}
 	}()
@@ -3044,7 +3047,7 @@
 	if tpInst.InstanceControl.Onu == "single-instance" && sq.direction == tp_pb.Direction_UPSTREAM {
 		tpInstances := f.techprofile.FindAllTpInstances(ctx, f.deviceHandler.device.Id, sq.tpID, sq.intfID, sq.onuID).([]tp_pb.TechProfileInstance)
 		for i := 0; i < len(tpInstances); i++ {
-			tpI := tpInstances[i]
+			tpI := &tpInstances[i]
 			if tpI.SubscriberIdentifier != tpInst.SubscriberIdentifier &&
 				tpI.UsScheduler.AllocId == tpInst.UsScheduler.AllocId {
 				logger.Debugw(ctx, "alloc-is-in-use-on-another-uni",
diff --git a/internal/pkg/core/openolt_groupmgr.go b/internal/pkg/core/openolt_groupmgr.go
index f52c481..9b40516 100644
--- a/internal/pkg/core/openolt_groupmgr.go
+++ b/internal/pkg/core/openolt_groupmgr.go
@@ -70,18 +70,18 @@
 		Command: openoltpb2.Group_SET_MEMBERS,
 		Action:  g.buildGroupAction(),
 	}
-	logger.Debugw(ctx, "sending-group-to-device", log.Fields{"groupToOlt": groupToOlt})
+	logger.Debugw(ctx, "sending-group-to-device", log.Fields{"group-id": groupToOlt.GroupId})
 	subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), g.deviceHandler.cfg.RPCTimeout)
 	_, err := g.deviceHandler.Client.PerformGroupOperation(subCtx, &groupToOlt)
 	cancel()
 	if err != nil {
-		return olterrors.NewErrAdapter("add-group-operation-failed", log.Fields{"groupToOlt": groupToOlt}, err)
+		return olterrors.NewErrAdapter("add-group-operation-failed", log.Fields{"group-id": groupToOlt.GroupId}, err)
 	}
 	// group members not created yet. So let's store the group
 	if err := g.resourceMgr.AddFlowGroupToKVStore(ctx, group, true); err != nil {
 		return olterrors.NewErrPersistence("add", "flow-group", uint64(group.Desc.GroupId), log.Fields{"group": group}, err)
 	}
-	logger.Infow(ctx, "add-group-operation-performed-on-the-device-successfully ", log.Fields{"groupToOlt": groupToOlt})
+	logger.Infow(ctx, "add-group-operation-performed-on-the-device-successfully ", log.Fields{"group-id": groupToOlt.GroupId})
 	return nil
 }
 
@@ -95,19 +95,19 @@
 	groupToOlt := openoltpb2.Group{
 		GroupId: group.Desc.GroupId,
 	}
-	logger.Debugw(ctx, "deleting-group-from-device", log.Fields{"groupToOlt": groupToOlt})
+	logger.Debugw(ctx, "deleting-group-from-device", log.Fields{"group-id": groupToOlt.GroupId})
 	subCtx, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), g.deviceHandler.cfg.RPCTimeout)
 	_, err := g.deviceHandler.Client.DeleteGroup(subCtx, &groupToOlt)
 	cancel()
 	if err != nil {
-		logger.Errorw(ctx, "delete-group-failed-on-dev", log.Fields{"groupToOlt": groupToOlt, "err": err})
-		return olterrors.NewErrAdapter("delete-group-operation-failed", log.Fields{"groupToOlt": groupToOlt}, err)
+		logger.Errorw(ctx, "delete-group-failed-on-dev", log.Fields{"group-id": groupToOlt.GroupId, "err": err})
+		return olterrors.NewErrAdapter("delete-group-operation-failed", log.Fields{"group-id": groupToOlt.GroupId}, err)
 	}
 	// remove group from the store
 	if err := g.resourceMgr.RemoveFlowGroupFromKVStore(ctx, group.Desc.GroupId, false); err != nil {
 		return olterrors.NewErrPersistence("delete", "flow-group", uint64(group.Desc.GroupId), log.Fields{"group": group}, err)
 	}
-	logger.Debugw(ctx, "delete-group-operation-performed-on-the-device-successfully ", log.Fields{"groupToOlt": groupToOlt})
+	logger.Debugw(ctx, "delete-group-operation-performed-on-the-device-successfully ", log.Fields{"group-id": groupToOlt.GroupId})
 	return nil
 }