diff --git a/adaptercore/openolt_eventmgr.go b/adaptercore/openolt_eventmgr.go
index 4c74361..2f896f5 100644
--- a/adaptercore/openolt_eventmgr.go
+++ b/adaptercore/openolt_eventmgr.go
@@ -19,6 +19,7 @@
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/opencord/voltha-lib-go/v2/pkg/adapters/adapterif"
 	"github.com/opencord/voltha-lib-go/v2/pkg/log"
@@ -43,6 +44,8 @@
 	onuProcessingErrorEvent = "ONU_PROCESSING_ERROR"
 	onuTiwiEvent            = "ONU_TRANSMISSION_WARNING"
 	onuLossOmciEvent        = "ONU_LOSS_OF_OMCI_CHANNEL"
+	onuLossOfKeySyncEvent   = "ONU_LOSS_OF_KEY_SYNC"
+	onuLossOfFrameEvent     = "ONU_LOSS_OF_FRAME"
 )
 
 const (
@@ -59,6 +62,19 @@
 	communication = voltha.EventCategory_COMMUNICATION
 )
 
+const (
+	// statusCheckOn represents status check On
+	statusCheckOn = "on"
+	// statusCheckOff represents status check Off
+	statusCheckOff = "off"
+	// operationStateUp represents operation state Up
+	operationStateUp = "up"
+	// operationStateDown represents operation state Down
+	operationStateDown = "down"
+	// base10 represents base 10 conversion
+	base10 = 10
+)
+
 // OpenOltEventMgr struct contains
 type OpenOltEventMgr struct {
 	eventProxy adapterif.EventProxy
@@ -75,39 +91,38 @@
 
 // ProcessEvents is function to process and publish OpenOLT event
 func (em *OpenOltEventMgr) ProcessEvents(alarmInd *oop.AlarmIndication, deviceID string, raisedTs int64) {
-
+	var err error
 	switch alarmInd.Data.(type) {
 	case *oop.AlarmIndication_LosInd:
 		log.Infow("Received LOS indication", log.Fields{"alarm_ind": alarmInd})
-		em.oltLosIndication(alarmInd.GetLosInd(), deviceID, raisedTs)
+		err = em.oltLosIndication(alarmInd.GetLosInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_OnuAlarmInd:
 		log.Infow("Received onu alarm indication ", log.Fields{"alarm_ind": alarmInd})
-		em.onuAlarmIndication(alarmInd.GetOnuAlarmInd(), deviceID, raisedTs)
+		err = em.onuAlarmIndication(alarmInd.GetOnuAlarmInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_DyingGaspInd:
 		log.Infow("Received dying gasp indication", log.Fields{"alarm_ind": alarmInd})
-		em.onuDyingGaspIndication(alarmInd.GetDyingGaspInd(), deviceID, raisedTs)
-
+		err = em.onuDyingGaspIndication(alarmInd.GetDyingGaspInd(), deviceID, raisedTs)
 	case *oop.AlarmIndication_OnuActivationFailInd:
 		log.Infow("Received onu activation fail indication ", log.Fields{"alarm_ind": alarmInd})
-		em.onuActivationFailIndication(alarmInd.GetOnuActivationFailInd(), deviceID, raisedTs)
+		err = em.onuActivationFailIndication(alarmInd.GetOnuActivationFailInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_OnuLossOmciInd:
 		log.Infow("Received onu loss omci indication ", log.Fields{"alarm_ind": alarmInd})
-		em.onuLossOmciIndication(alarmInd.GetOnuLossOmciInd(), deviceID, raisedTs)
+		err = em.onuLossOmciIndication(alarmInd.GetOnuLossOmciInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_OnuDriftOfWindowInd:
 		log.Infow("Received onu drift of window indication ", log.Fields{"alarm_ind": alarmInd})
-		em.onuDriftOfWindowIndication(alarmInd.GetOnuDriftOfWindowInd(), deviceID, raisedTs)
+		err = em.onuDriftOfWindowIndication(alarmInd.GetOnuDriftOfWindowInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_OnuSignalDegradeInd:
 		log.Infow("Received onu signal degrade indication ", log.Fields{"alarm_ind": alarmInd})
-		em.onuSignalDegradeIndication(alarmInd.GetOnuSignalDegradeInd(), deviceID, raisedTs)
+		err = em.onuSignalDegradeIndication(alarmInd.GetOnuSignalDegradeInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_OnuSignalsFailInd:
 		log.Infow("Received onu signal fail indication ", log.Fields{"alarm_ind": alarmInd})
-		em.onuSignalsFailIndication(alarmInd.GetOnuSignalsFailInd(), deviceID, raisedTs)
+		err = em.onuSignalsFailIndication(alarmInd.GetOnuSignalsFailInd(), deviceID, raisedTs)
 
 	case *oop.AlarmIndication_OnuProcessingErrorInd:
 		log.Infow("Received onu startup fail indication ", log.Fields{"alarm_ind": alarmInd})
@@ -115,40 +130,51 @@
 	case *oop.AlarmIndication_OnuTiwiInd:
 		log.Infow("Received onu transmission warning indication ", log.Fields{"alarm_ind": alarmInd})
 		log.Infow("Not implemented yet", log.Fields{"alarm_ind": "Onu-Transmission-indication"})
+	case *oop.AlarmIndication_OnuLossOfSyncFailInd:
+		log.Infow("Received onu Loss of Sync Fail indication ", log.Fields{"alarm_ind": alarmInd})
+		err = em.onuLossOfSyncIndication(alarmInd.GetOnuLossOfSyncFailInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuItuPonStatsInd:
+		log.Infow("Received onu Itu Pon Stats indication ", log.Fields{"alarm_ind": alarmInd})
+		log.Infow("Not implemented yet", log.Fields{"alarm_ind": alarmInd})
 	default:
 		log.Errorw("Received unknown indication type", log.Fields{"alarm_ind": alarmInd})
 
 	}
+	if err != nil {
+		log.Errorw("Failed to publish message to KAFKA", log.Fields{"error": err})
+	}
 }
 
 // oltUpDownIndication handles Up and Down state of an OLT
-func (em *OpenOltEventMgr) oltUpDownIndication(oltIndication *oop.OltIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) oltUpDownIndication(oltIndication *oop.OltIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["oper-state"] = string(oltIndication.OperState)
+	context["oper-state"] = oltIndication.OperState
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if oltIndication.OperState == "down" {
+	if oltIndication.OperState == operationStateDown {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "RAISE_EVENT")
-	} else if oltIndication.OperState == "up" {
+	} else if oltIndication.OperState == operationStateUp {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "CLEAR_EVENT")
 	}
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, olt, raisedTs); err != nil {
 		log.Errorw("Failed to send OLT event", log.Fields{"err": err})
+		return err
 	}
 	log.Infow("OLT UpDown event sent to KAFKA", log.Fields{})
+	return nil
 }
 
 // OnuDiscoveryIndication is an exported method to handle ONU discovery event
-func (em *OpenOltEventMgr) OnuDiscoveryIndication(onuDisc *oop.OnuDiscIndication, deviceID string, OnuID uint32, serialNumber string, raisedTs int64) {
+func (em *OpenOltEventMgr) OnuDiscoveryIndication(onuDisc *oop.OnuDiscIndication, deviceID string, OnuID uint32, serialNumber string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["onu-id"] = string(OnuID)
-	context["intf-id"] = string(onuDisc.IntfId)
+	context["onu-id"] = strconv.FormatUint(uint64(OnuID), base10)
+	context["intf-id"] = strconv.FormatUint(uint64(onuDisc.IntfId), base10)
 	context["serial-number"] = serialNumber
 	/* Populating device event body */
 	de.Context = context
@@ -157,19 +183,21 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, equipment, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU discovery event", log.Fields{"serial-number": serialNumber, "intf-id": onuDisc.IntfId})
+		return err
 	}
 	log.Infow("ONU discovery event sent to KAFKA", log.Fields{"serial-number": serialNumber, "intf-id": onuDisc.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) oltLosIndication(oltLos *oop.LosIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) oltLosIndication(oltLos *oop.LosIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["intf-id"] = string(oltLos.IntfId)
+	context["intf-id"] = strconv.FormatUint(uint64(oltLos.IntfId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if oltLos.Status == "on" {
+	if oltLos.Status == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "RAISE_EVENT")
 	} else {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "CLEAR_EVENT")
@@ -177,11 +205,13 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, olt, raisedTs); err != nil {
 		log.Errorw("Failed to send OLT loss of signal event", log.Fields{"intf-id": oltLos.IntfId})
+		return err
 	}
 	log.Infow("OLT LOS event sent to KAFKA", log.Fields{"intf-id": oltLos.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuDyingGaspIndication(dgi *oop.DyingGaspIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuDyingGaspIndication(dgi *oop.DyingGaspIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	var serialNumber string
 	context := make(map[string]string)
@@ -192,12 +222,12 @@
 		serialNumber = onu.(*OnuDevice).serialNumber
 	}
 	context["serial-number"] = serialNumber
-	context["intf-id"] = string(dgi.IntfId)
-	context["onu-id"] = string(dgi.OnuId)
+	context["intf-id"] = strconv.FormatUint(uint64(dgi.IntfId), base10)
+	context["onu-id"] = strconv.FormatUint(uint64(dgi.OnuId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if dgi.Status == "on" {
+	if dgi.Status == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "RAISE_EVENT")
 	} else {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "CLEAR_EVENT")
@@ -205,49 +235,57 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU Dying gasp event", log.Fields{"intf-id": dgi.IntfId, "onu-id": dgi.OnuId})
+		return err
 	}
 	log.Infow("ONU dying gasp event sent to KAFKA", log.Fields{"intf-id": dgi.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuAlarmIndication(onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuAlarmIndication(onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["intf-id"] = string(onuAlarm.IntfId)
-	context["onu-id"] = string(onuAlarm.OnuId)
+	context["intf-id"] = strconv.FormatUint(uint64(onuAlarm.IntfId), base10)
+	context["onu-id"] = strconv.FormatUint(uint64(onuAlarm.OnuId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if onuAlarm.LosStatus == "on" {
+	if onuAlarm.LosStatus == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "RAISE_EVENT")
-	} else if onuAlarm.LosStatus == "off" {
+	} else if onuAlarm.LosStatus == statusCheckOff {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "CLEAR_EVENT")
-	} else if onuAlarm.LobStatus == "on" {
+	} else if onuAlarm.LobStatus == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "RAISE_EVENT")
-	} else if onuAlarm.LobStatus == "off" {
+	} else if onuAlarm.LobStatus == statusCheckOff {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "CLEAR_EVENT")
-	} else if onuAlarm.LopcMissStatus == "on" {
+	} else if onuAlarm.LopcMissStatus == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "RAISE_EVENT")
-	} else if onuAlarm.LopcMissStatus == "off" {
+	} else if onuAlarm.LopcMissStatus == statusCheckOff {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "CLEAR_EVENT")
-	} else if onuAlarm.LopcMicErrorStatus == "on" {
+	} else if onuAlarm.LopcMicErrorStatus == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "RAISE_EVENT")
-	} else if onuAlarm.LopcMicErrorStatus == "off" {
+	} else if onuAlarm.LopcMicErrorStatus == statusCheckOff {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "CLEAR_EVENT")
+	} else if onuAlarm.LofiStatus == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "RAISE_EVENT")
+	} else if onuAlarm.LofiStatus == statusCheckOff {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "CLEAR_EVENT")
 	}
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, onu, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU Los event", log.Fields{"onu-id": onuAlarm.OnuId, "intf-id": onuAlarm.IntfId})
+		return err
 	}
 	log.Infow("ONU LOS event sent to KAFKA", log.Fields{"onu-id": onuAlarm.OnuId, "intf-id": onuAlarm.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuActivationFailIndication(oaf *oop.OnuActivationFailureIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuActivationFailIndication(oaf *oop.OnuActivationFailureIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["intf-id"] = string(oaf.IntfId)
-	context["onu-id"] = string(oaf.OnuId)
+	context["intf-id"] = strconv.FormatUint(uint64(oaf.IntfId), base10)
+	context["onu-id"] = strconv.FormatUint(uint64(oaf.OnuId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
@@ -255,20 +293,22 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, equipment, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU activation failure event", log.Fields{"onu-id": oaf.OnuId, "intf-id": oaf.IntfId})
+		return err
 	}
 	log.Infow("ONU activation failure event sent to KAFKA", log.Fields{"onu-id": oaf.OnuId, "intf-id": oaf.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuLossOmciIndication(onuLossOmci *oop.OnuLossOfOmciChannelIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuLossOmciIndication(onuLossOmci *oop.OnuLossOfOmciChannelIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["intf-id"] = string(onuLossOmci.IntfId)
-	context["onu-id"] = string(onuLossOmci.OnuId)
+	context["intf-id"] = strconv.FormatUint(uint64(onuLossOmci.IntfId), base10)
+	context["onu-id"] = strconv.FormatUint(uint64(onuLossOmci.OnuId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if onuLossOmci.Status == "on" {
+	if onuLossOmci.Status == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "RAISE_EVENT")
 	} else {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "CLEAR_EVENT")
@@ -276,22 +316,24 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU loss of OMCI channel event", log.Fields{"onu-id": onuLossOmci.OnuId, "intf-id": onuLossOmci.IntfId})
+		return err
 	}
 	log.Infow("ONU loss of OMCI channel event sent to KAFKA", log.Fields{"onu-id": onuLossOmci.OnuId, "intf-id": onuLossOmci.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuDriftOfWindowIndication(onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuDriftOfWindowIndication(onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["intf-id"] = string(onuDriftWindow.IntfId)
-	context["onu-id"] = string(onuDriftWindow.OnuId)
-	context["drift"] = string(onuDriftWindow.OnuId)
-	context["new-eqd"] = string(onuDriftWindow.OnuId)
+	context["intf-id"] = strconv.FormatUint(uint64(onuDriftWindow.IntfId), base10)
+	context["onu-id"] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
+	context["drift"] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
+	context["new-eqd"] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if onuDriftWindow.Status == "on" {
+	if onuDriftWindow.Status == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "RAISE_EVENT")
 	} else {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "CLEAR_EVENT")
@@ -299,20 +341,22 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU drift of window event", log.Fields{"onu-id": onuDriftWindow.OnuId, "intf-id": onuDriftWindow.IntfId})
+		return err
 	}
 	log.Infow("ONU drift of window event sent to KAFKA", log.Fields{"onu-id": onuDriftWindow.OnuId, "intf-id": onuDriftWindow.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuSignalDegradeIndication(onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuSignalDegradeIndication(onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["intf-id"] = string(onuSignalDegrade.IntfId)
-	context["onu-id"] = string(onuSignalDegrade.OnuId)
+	context["intf-id"] = strconv.FormatUint(uint64(onuSignalDegrade.IntfId), base10)
+	context["onu-id"] = strconv.FormatUint(uint64(onuSignalDegrade.OnuId), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if onuSignalDegrade.Status == "on" {
+	if onuSignalDegrade.Status == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "RAISE_EVENT")
 	} else {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "CLEAR_EVENT")
@@ -320,21 +364,23 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU signals degrade event", log.Fields{"onu-id": onuSignalDegrade.OnuId, "intf-id": onuSignalDegrade.IntfId})
+		return err
 	}
 	log.Infow("ONU signal degrade event sent to KAFKA", log.Fields{"onu-id": onuSignalDegrade.OnuId, "intf-id": onuSignalDegrade.IntfId})
+	return nil
 }
 
-func (em *OpenOltEventMgr) onuSignalsFailIndication(onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) {
+func (em *OpenOltEventMgr) onuSignalsFailIndication(onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) error {
 	var de voltha.DeviceEvent
 	context := make(map[string]string)
 	/* Populating event context */
-	context["onu-id"] = string(onuSignalsFail.OnuId)
-	context["intf-id"] = string(onuSignalsFail.IntfId)
-	context["inverse-bit-error-rate"] = string(onuSignalsFail.InverseBitErrorRate)
+	context["onu-id"] = strconv.FormatUint(uint64(onuSignalsFail.OnuId), base10)
+	context["intf-id"] = strconv.FormatUint(uint64(onuSignalsFail.IntfId), base10)
+	context["inverse-bit-error-rate"] = strconv.FormatUint(uint64(onuSignalsFail.InverseBitErrorRate), base10)
 	/* Populating device event body */
 	de.Context = context
 	de.ResourceId = deviceID
-	if onuSignalsFail.Status == "on" {
+	if onuSignalsFail.Status == statusCheckOn {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "RAISE_EVENT")
 	} else {
 		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "CLEAR_EVENT")
@@ -342,6 +388,32 @@
 	/* Send event to KAFKA */
 	if err := em.eventProxy.SendDeviceEvent(&de, communication, pon, raisedTs); err != nil {
 		log.Errorw("Failed to send ONU signals fail event", log.Fields{"onu-id": onuSignalsFail.OnuId, "intf-id": onuSignalsFail.IntfId})
+		return err
 	}
 	log.Infow("ONU signals fail event sent to KAFKA", log.Fields{"onu-id": onuSignalsFail.OnuId, "intf-id": onuSignalsFail.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuLossOfSyncIndication(onuLOKI *oop.OnuLossOfKeySyncFailureIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context["onu-id"] = strconv.FormatUint(uint64(onuLOKI.OnuId), base10)
+	context["intf-id"] = strconv.FormatUint(uint64(onuLOKI.IntfId), base10)
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuLOKI.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "CLEAR_EVENT")
+	}
+
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(&de, security, onu, raisedTs); err != nil {
+		log.Errorw("Failed to send ONU loss of key sync event", log.Fields{"onu-id": onuLOKI.OnuId, "intf-id": onuLOKI.IntfId})
+		return err
+	}
+	log.Infow("ONU loss of key sync event sent to KAFKA", log.Fields{"onu-id": onuLOKI.OnuId, "intf-id": onuLOKI.IntfId})
+	return nil
 }