diff --git a/channels/events/streams.go b/channels/events/streams.go
index c5341b81cb..65455687df 100644
--- a/channels/events/streams.go
+++ b/channels/events/streams.go
@@ -32,7 +32,7 @@ func NewEventStoreMiddleware(ctx context.Context, svc channels.Service, url stri
 		return nil, err
 	}
 
-	rolesSvcEventStoreMiddleware := rmEvents.NewRoleManagerEventStore("channels", svc, publisher)
+	rolesSvcEventStoreMiddleware := rmEvents.NewRoleManagerEventStore("channels", channelPrefix, svc, publisher)
 	return &eventStore{
 		svc:                   svc,
 		Publisher:             publisher,
diff --git a/clients/events/events.go b/clients/events/events.go
index 5d8ea7d9cb..7b163b3b5e 100644
--- a/clients/events/events.go
+++ b/clients/events/events.go
@@ -11,7 +11,7 @@ import (
 )
 
 const (
-	clientPrefix       = "thing."
+	clientPrefix       = "client."
 	clientCreate       = clientPrefix + "create"
 	clientUpdate       = clientPrefix + "update"
 	clientChangeStatus = clientPrefix + "change_status"
diff --git a/clients/events/streams.go b/clients/events/streams.go
index 253f6f77d7..64fb9ddd5a 100644
--- a/clients/events/streams.go
+++ b/clients/events/streams.go
@@ -30,7 +30,7 @@ func NewEventStoreMiddleware(ctx context.Context, svc clients.Service, url strin
 	if err != nil {
 		return nil, err
 	}
-	res := rmEvents.NewRoleManagerEventStore("clients", svc, publisher)
+	res := rmEvents.NewRoleManagerEventStore("clients", clientPrefix, svc, publisher)
 
 	return &eventStore{
 		svc:                   svc,
diff --git a/domains/events/streams.go b/domains/events/streams.go
index e45a10f4a0..8035ef96ac 100644
--- a/domains/events/streams.go
+++ b/domains/events/streams.go
@@ -31,7 +31,7 @@ func NewEventStoreMiddleware(ctx context.Context, svc domains.Service, url strin
 		return nil, err
 	}
 
-	res := rmEvents.NewRoleManagerEventStore("domains", svc, publisher)
+	res := rmEvents.NewRoleManagerEventStore("domains", domainPrefix, svc, publisher)
 
 	return &eventStore{
 		svc:                   svc,
diff --git a/groups/events/streams.go b/groups/events/streams.go
index 8d91671285..6886fcd8f1 100644
--- a/groups/events/streams.go
+++ b/groups/events/streams.go
@@ -30,7 +30,7 @@ func New(ctx context.Context, svc groups.Service, url string) (groups.Service, e
 	if err != nil {
 		return nil, err
 	}
-	rmes := rmEvents.NewRoleManagerEventStore("groups", svc, publisher)
+	rmes := rmEvents.NewRoleManagerEventStore("groups", groupPrefix, svc, publisher)
 
 	return &eventStore{
 		svc:                   svc,
diff --git a/pkg/roles/rolemanager/events/events.go b/pkg/roles/rolemanager/events/events.go
index 80daff19cb..6039810a49 100644
--- a/pkg/roles/rolemanager/events/events.go
+++ b/pkg/roles/rolemanager/events/events.go
@@ -2,3 +2,351 @@
 // SPDX-License-Identifier: Apache-2.0
 
 package events
+
+import (
+	"github.com/absmach/supermq/pkg/events"
+	"github.com/absmach/supermq/pkg/roles"
+)
+
+const (
+	addRole                  = "role.add"
+	removeRole               = "role.remove"
+	updateRole               = "role.update"
+	viewRole                 = "role.view"
+	viewAllRole              = "role.view_all"
+	listAvailableActions     = "role.list_available_actions"
+	addRoleActions           = "role.actions.add"
+	listRoleActions          = "role.actions.ist"
+	checkRoleActions         = "role.actions.check"
+	removeRoleActions        = "role.actions.remove"
+	removeAllRoleActions     = "role.actions.remove_all"
+	addRoleMembers           = "role.members.add"
+	listRoleMembers          = "role.members.list"
+	checkRoleMembers         = "role.members.check"
+	removeRoleMembers        = "role.members.remove"
+	removeRoleAllMembers     = "role.members.remove_all"
+	removeMemberFromAllRoles = "role.members.remove_from_all_roles"
+)
+
+var (
+	_ events.Event = (*addRoleEvent)(nil)
+	_ events.Event = (*removeRoleEvent)(nil)
+	_ events.Event = (*updateRoleEvent)(nil)
+	_ events.Event = (*retrieveRoleEvent)(nil)
+	_ events.Event = (*retrieveAllRolesEvent)(nil)
+	_ events.Event = (*listAvailableActionsEvent)(nil)
+	_ events.Event = (*roleAddActionsEvent)(nil)
+	_ events.Event = (*roleListActionsEvent)(nil)
+	_ events.Event = (*roleCheckActionsExistsEvent)(nil)
+	_ events.Event = (*roleRemoveActionsEvent)(nil)
+	_ events.Event = (*roleRemoveAllActionsEvent)(nil)
+	_ events.Event = (*roleAddMembersEvent)(nil)
+	_ events.Event = (*roleListMembersEvent)(nil)
+	_ events.Event = (*roleCheckMembersExistsEvent)(nil)
+	_ events.Event = (*roleRemoveMembersEvent)(nil)
+	_ events.Event = (*roleRemoveAllMembersEvent)(nil)
+	_ events.Event = (*removeMemberFromAllRolesEvent)(nil)
+)
+
+type addRoleEvent struct {
+	operationPrefix string
+	roles.Role
+}
+
+func (are addRoleEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation":  are.operationPrefix + addRole,
+		"id":         are.ID,
+		"name":       are.Name,
+		"entity_id":  are.EntityID,
+		"created_by": are.CreatedBy,
+		"created_at": are.CreatedAt,
+		"updated_by": are.UpdatedBy,
+		"updated_at": are.UpdatedAt,
+	}
+	return val, nil
+}
+
+type removeRoleEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+}
+
+func (rre removeRoleEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rre.operationPrefix + removeRole,
+		"entity_id": rre.entityID,
+		"role_id":   rre.roleID,
+		"role_name": rre.roleName,
+	}
+	return val, nil
+}
+
+type updateRoleEvent struct {
+	operationPrefix string
+	roles.Role
+}
+
+func (ure updateRoleEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation":  ure.operationPrefix + updateRole,
+		"id":         ure.ID,
+		"name":       ure.Name,
+		"entity_id":  ure.EntityID,
+		"created_by": ure.CreatedBy,
+		"created_at": ure.CreatedAt,
+		"updated_by": ure.UpdatedBy,
+		"updated_at": ure.UpdatedAt,
+	}
+	return val, nil
+}
+
+type retrieveRoleEvent struct {
+	operationPrefix string
+	roles.Role
+}
+
+func (rre retrieveRoleEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation":  rre.operationPrefix + viewRole,
+		"id":         rre.ID,
+		"name":       rre.Name,
+		"entity_id":  rre.EntityID,
+		"created_by": rre.CreatedBy,
+		"created_at": rre.CreatedAt,
+		"updated_by": rre.UpdatedBy,
+		"updated_at": rre.UpdatedAt,
+	}
+	return val, nil
+}
+
+type retrieveAllRolesEvent struct {
+	operationPrefix string
+	entityID        string
+	limit           uint64
+	offset          uint64
+}
+
+func (rare retrieveAllRolesEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rare.operationPrefix + viewAllRole,
+		"entity_id": rare.entityID,
+		"limit":     rare.limit,
+		"offset":    rare.offset,
+	}
+	return val, nil
+}
+
+type listAvailableActionsEvent struct {
+	operationPrefix string
+}
+
+func (laae listAvailableActionsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": laae.operationPrefix + listAvailableActions,
+	}
+	return val, nil
+}
+
+type roleAddActionsEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	actions         []string
+}
+
+func (raae roleAddActionsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": raae.operationPrefix + addRoleActions,
+		"entity_id": raae.entityID,
+		"role_id":   raae.roleID,
+		"role_name": raae.roleName,
+		"actions":   raae.actions,
+	}
+	return val, nil
+}
+
+type roleListActionsEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+}
+
+func (rlae roleListActionsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rlae.operationPrefix + listRoleActions,
+		"entity_id": rlae.entityID,
+		"role_id":   rlae.roleID,
+		"role_name": rlae.roleName,
+	}
+	return val, nil
+}
+
+type roleCheckActionsExistsEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	actions         []string
+	isAllExists     bool
+}
+
+func (rcaee roleCheckActionsExistsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation":     rcaee.operationPrefix + checkRoleActions,
+		"entity_id":     rcaee.entityID,
+		"role_id":       rcaee.roleID,
+		"role_name":     rcaee.roleName,
+		"actions":       rcaee.actions,
+		"is_all_exists": rcaee.isAllExists,
+	}
+	return val, nil
+}
+
+type roleRemoveActionsEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	actions         []string
+}
+
+func (rrae roleRemoveActionsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rrae.operationPrefix + removeRoleActions,
+		"entity_id": rrae.entityID,
+		"role_id":   rrae.roleID,
+		"role_name": rrae.roleName,
+		"actions":   rrae.actions,
+	}
+	return val, nil
+}
+
+type roleRemoveAllActionsEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+}
+
+func (rraae roleRemoveAllActionsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rraae.operationPrefix + removeAllRoleActions,
+		"entity_id": rraae.entityID,
+		"role_id":   rraae.roleID,
+		"role_name": rraae.roleName,
+	}
+	return val, nil
+}
+
+type roleAddMembersEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	members         []string
+}
+
+func (rame roleAddMembersEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rame.operationPrefix + addRoleMembers,
+		"entity_id": rame.entityID,
+		"role_id":   rame.roleID,
+		"role_name": rame.roleName,
+		"members":   rame.members,
+	}
+	return val, nil
+}
+
+type roleListMembersEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	limit           uint64
+	offset          uint64
+}
+
+func (rlme roleListMembersEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rlme.operationPrefix + listRoleMembers,
+		"entity_id": rlme.entityID,
+		"role_id":   rlme.roleID,
+		"role_name": rlme.roleName,
+		"limit":     rlme.limit,
+		"offset":    rlme.offset,
+	}
+	return val, nil
+}
+
+type roleCheckMembersExistsEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	members         []string
+}
+
+func (rcmee roleCheckMembersExistsEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rcmee.operationPrefix + checkRoleMembers,
+		"entity_id": rcmee.entityID,
+		"role_id":   rcmee.roleID,
+		"role_name": rcmee.roleName,
+		"members":   rcmee.members,
+	}
+	return val, nil
+}
+
+type roleRemoveMembersEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+	members         []string
+}
+
+func (rrme roleRemoveMembersEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rrme.operationPrefix + removeRoleMembers,
+		"entity_id": rrme.entityID,
+		"role_id":   rrme.roleID,
+		"role_name": rrme.roleName,
+		"members":   rrme.members,
+	}
+	return val, nil
+}
+
+type roleRemoveAllMembersEvent struct {
+	operationPrefix string
+	entityID        string
+	roleID          string
+	roleName        string
+}
+
+func (rrame roleRemoveAllMembersEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rrame.operationPrefix + removeRoleAllMembers,
+		"entity_id": rrame.entityID,
+		"role_id":   rrame.roleID,
+		"role_name": rrame.roleName,
+	}
+	return val, nil
+}
+
+type removeMemberFromAllRolesEvent struct {
+	operationPrefix string
+	memberID        string
+}
+
+func (rmare removeMemberFromAllRolesEvent) Encode() (map[string]interface{}, error) {
+	val := map[string]interface{}{
+		"operation": rmare.operationPrefix + removeMemberFromAllRoles,
+		"member_id": rmare.memberID,
+	}
+	return val, nil
+}
diff --git a/pkg/roles/rolemanager/events/streams.go b/pkg/roles/rolemanager/events/streams.go
index 6078f3e3fb..12e687cdcc 100644
--- a/pkg/roles/rolemanager/events/streams.go
+++ b/pkg/roles/rolemanager/events/streams.go
@@ -15,13 +15,14 @@ var _ roles.RoleManager = (*RoleManagerEventStore)(nil)
 
 type RoleManagerEventStore struct {
 	events.Publisher
-	svc     roles.RoleManager
-	svcName string
+	svc             roles.RoleManager
+	operationPrefix string
+	svcName         string
 }
 
 // NewEventStoreMiddleware returns wrapper around auth service that sends
 // events to event store.
-func NewRoleManagerEventStore(svcName string, svc roles.RoleManager, publisher events.Publisher) RoleManagerEventStore {
+func NewRoleManagerEventStore(svcName, operationPrefix string, svc roles.RoleManager, publisher events.Publisher) RoleManagerEventStore {
 	return RoleManagerEventStore{
 		svcName:   svcName,
 		svc:       svc,
@@ -29,70 +30,285 @@ func NewRoleManagerEventStore(svcName string, svc roles.RoleManager, publisher e
 	}
 }
 
-func (res *RoleManagerEventStore) AddRole(ctx context.Context, session authn.Session, entityID, roleName string, optionalActions []string, optionalMembers []string) (roles.Role, error) {
-	return res.svc.AddRole(ctx, session, entityID, roleName, optionalActions, optionalMembers)
+func (rmes *RoleManagerEventStore) AddRole(ctx context.Context, session authn.Session, entityID, roleName string, optionalActions []string, optionalMembers []string) (roles.Role, error) {
+	ro, err := rmes.svc.AddRole(ctx, session, entityID, roleName, optionalActions, optionalMembers)
+	if err != nil {
+		return ro, err
+	}
+
+	e := addRoleEvent{
+		operationPrefix: rmes.operationPrefix,
+		Role:            ro,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return ro, err
+	}
+	return ro, nil
 }
 
-func (res *RoleManagerEventStore) RemoveRole(ctx context.Context, session authn.Session, entityID, roleName string) error {
-	return res.svc.RemoveRole(ctx, session, entityID, roleName)
+func (rmes *RoleManagerEventStore) RemoveRole(ctx context.Context, session authn.Session, entityID, roleName string) error {
+	if err := rmes.svc.RemoveRole(ctx, session, entityID, roleName); err != nil {
+		return err
+	}
+	e := removeRoleEvent{
+		operationPrefix: rmes.operationPrefix,
+		roleName:        roleName,
+		entityID:        entityID,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (res *RoleManagerEventStore) UpdateRoleName(ctx context.Context, session authn.Session, entityID, oldRoleName, newRoleName string) (roles.Role, error) {
-	return res.svc.UpdateRoleName(ctx, session, entityID, oldRoleName, newRoleName)
+func (rmes *RoleManagerEventStore) UpdateRoleName(ctx context.Context, session authn.Session, entityID, oldRoleName, newRoleName string) (roles.Role, error) {
+	ro, err := rmes.svc.UpdateRoleName(ctx, session, entityID, oldRoleName, newRoleName)
+	if err != nil {
+		return ro, err
+	}
+
+	e := updateRoleEvent{
+		operationPrefix: rmes.operationPrefix,
+		Role:            ro,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return ro, err
+	}
+	return ro, nil
 }
 
-func (res *RoleManagerEventStore) RetrieveRole(ctx context.Context, session authn.Session, entityID, roleName string) (roles.Role, error) {
-	return res.svc.RetrieveRole(ctx, session, entityID, roleName)
+func (rmes *RoleManagerEventStore) RetrieveRole(ctx context.Context, session authn.Session, entityID, roleName string) (roles.Role, error) {
+	ro, err := rmes.svc.RetrieveRole(ctx, session, entityID, roleName)
+	if err != nil {
+		return ro, err
+	}
+	e := retrieveRoleEvent{
+		operationPrefix: rmes.operationPrefix,
+		Role:            ro,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return ro, err
+	}
+	return ro, nil
 }
 
-func (res *RoleManagerEventStore) RetrieveAllRoles(ctx context.Context, session authn.Session, entityID string, limit, offset uint64) (roles.RolePage, error) {
-	return res.svc.RetrieveAllRoles(ctx, session, entityID, limit, offset)
+func (rmes *RoleManagerEventStore) RetrieveAllRoles(ctx context.Context, session authn.Session, entityID string, limit, offset uint64) (roles.RolePage, error) {
+	rp, err := rmes.svc.RetrieveAllRoles(ctx, session, entityID, limit, offset)
+	if err != nil {
+		return rp, err
+	}
+
+	e := retrieveAllRolesEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		limit:           limit,
+		offset:          offset,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return rp, err
+	}
+	return rp, nil
 }
 
-func (res *RoleManagerEventStore) ListAvailableActions(ctx context.Context, session authn.Session) ([]string, error) {
-	return res.svc.ListAvailableActions(ctx, session)
+func (rmes *RoleManagerEventStore) ListAvailableActions(ctx context.Context, session authn.Session) ([]string, error) {
+	actions, err := rmes.svc.ListAvailableActions(ctx, session)
+	if err != nil {
+		return actions, err
+	}
+	e := listAvailableActionsEvent{
+		operationPrefix: rmes.operationPrefix,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return actions, err
+	}
+	return actions, nil
 }
 
-func (res *RoleManagerEventStore) RoleAddActions(ctx context.Context, session authn.Session, entityID, roleName string, actions []string) (ops []string, err error) {
-	return res.svc.RoleAddActions(ctx, session, entityID, roleName, actions)
+func (rmes *RoleManagerEventStore) RoleAddActions(ctx context.Context, session authn.Session, entityID, roleName string, actions []string) ([]string, error) {
+	actions, err := rmes.svc.RoleAddActions(ctx, session, entityID, roleName, actions)
+	if err != nil {
+		return actions, err
+	}
+	e := roleAddActionsEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		actions:         actions,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return actions, err
+	}
+	return actions, nil
 }
 
-func (res *RoleManagerEventStore) RoleListActions(ctx context.Context, session authn.Session, entityID, roleName string) ([]string, error) {
-	return res.svc.RoleListActions(ctx, session, entityID, roleName)
+func (rmes *RoleManagerEventStore) RoleListActions(ctx context.Context, session authn.Session, entityID, roleName string) ([]string, error) {
+	actions, err := rmes.svc.RoleListActions(ctx, session, entityID, roleName)
+	if err != nil {
+		return actions, err
+	}
+
+	e := roleListActionsEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return actions, err
+	}
+	return actions, nil
 }
 
-func (res *RoleManagerEventStore) RoleCheckActionsExists(ctx context.Context, session authn.Session, entityID, roleName string, actions []string) (bool, error) {
-	return res.svc.RoleCheckActionsExists(ctx, session, entityID, roleName, actions)
+func (rmes *RoleManagerEventStore) RoleCheckActionsExists(ctx context.Context, session authn.Session, entityID, roleName string, actions []string) (bool, error) {
+	isAllExists, err := rmes.svc.RoleCheckActionsExists(ctx, session, entityID, roleName, actions)
+	if err != nil {
+		return isAllExists, err
+	}
+
+	e := roleCheckActionsExistsEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		actions:         actions,
+		isAllExists:     isAllExists,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return isAllExists, err
+	}
+	return isAllExists, nil
 }
 
-func (res *RoleManagerEventStore) RoleRemoveActions(ctx context.Context, session authn.Session, entityID, roleName string, actions []string) (err error) {
-	return res.svc.RoleRemoveActions(ctx, session, entityID, roleName, actions)
+func (rmes *RoleManagerEventStore) RoleRemoveActions(ctx context.Context, session authn.Session, entityID, roleName string, actions []string) (err error) {
+	if err := rmes.svc.RoleRemoveActions(ctx, session, entityID, roleName, actions); err != nil {
+		return err
+	}
+
+	e := roleRemoveActionsEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		actions:         actions,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (res *RoleManagerEventStore) RoleRemoveAllActions(ctx context.Context, session authn.Session, entityID, roleName string) error {
-	return res.svc.RoleRemoveAllActions(ctx, session, entityID, roleName)
+func (rmes *RoleManagerEventStore) RoleRemoveAllActions(ctx context.Context, session authn.Session, entityID, roleName string) error {
+	if err := rmes.svc.RoleRemoveAllActions(ctx, session, entityID, roleName); err != nil {
+		return err
+	}
+
+	e := roleRemoveAllActionsEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (res *RoleManagerEventStore) RoleAddMembers(ctx context.Context, session authn.Session, entityID, roleName string, members []string) ([]string, error) {
-	return res.svc.RoleAddMembers(ctx, session, entityID, roleName, members)
+func (rmes *RoleManagerEventStore) RoleAddMembers(ctx context.Context, session authn.Session, entityID, roleName string, members []string) ([]string, error) {
+	mems, err := rmes.svc.RoleAddMembers(ctx, session, entityID, roleName, members)
+	if err != nil {
+		return mems, err
+	}
+
+	e := roleAddMembersEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		members:         members,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return mems, err
+	}
+	return mems, nil
 }
 
-func (res *RoleManagerEventStore) RoleListMembers(ctx context.Context, session authn.Session, entityID, roleName string, limit, offset uint64) (roles.MembersPage, error) {
-	return res.svc.RoleListMembers(ctx, session, entityID, roleName, limit, offset)
+func (rmes *RoleManagerEventStore) RoleListMembers(ctx context.Context, session authn.Session, entityID, roleName string, limit, offset uint64) (roles.MembersPage, error) {
+	mp, err := rmes.svc.RoleListMembers(ctx, session, entityID, roleName, limit, offset)
+	if err != nil {
+		return mp, err
+	}
+
+	e := roleListMembersEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		limit:           limit,
+		offset:          offset,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return mp, err
+	}
+	return mp, nil
 }
 
-func (res *RoleManagerEventStore) RoleCheckMembersExists(ctx context.Context, session authn.Session, entityID, roleName string, members []string) (bool, error) {
-	return res.svc.RoleCheckMembersExists(ctx, session, entityID, roleName, members)
+func (rmes *RoleManagerEventStore) RoleCheckMembersExists(ctx context.Context, session authn.Session, entityID, roleName string, members []string) (bool, error) {
+	isAllExists, err := rmes.svc.RoleCheckMembersExists(ctx, session, entityID, roleName, members)
+	if err != nil {
+		return isAllExists, err
+	}
+
+	e := roleCheckMembersExistsEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		members:         members,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return isAllExists, err
+	}
+	return isAllExists, nil
 }
 
-func (res *RoleManagerEventStore) RoleRemoveMembers(ctx context.Context, session authn.Session, entityID, roleName string, members []string) (err error) {
-	return res.svc.RoleRemoveMembers(ctx, session, entityID, roleName, members)
+func (rmes *RoleManagerEventStore) RoleRemoveMembers(ctx context.Context, session authn.Session, entityID, roleName string, members []string) (err error) {
+	if err := rmes.svc.RoleRemoveMembers(ctx, session, entityID, roleName, members); err != nil {
+		return err
+	}
+
+	e := roleRemoveMembersEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+		members:         members,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (res *RoleManagerEventStore) RoleRemoveAllMembers(ctx context.Context, session authn.Session, entityID, roleName string) (err error) {
-	return res.svc.RoleRemoveAllMembers(ctx, session, entityID, roleName)
+func (rmes *RoleManagerEventStore) RoleRemoveAllMembers(ctx context.Context, session authn.Session, entityID, roleName string) (err error) {
+	if err := rmes.svc.RoleRemoveAllMembers(ctx, session, entityID, roleName); err != nil {
+		return err
+	}
+
+	e := roleRemoveAllMembersEvent{
+		operationPrefix: rmes.operationPrefix,
+		entityID:        entityID,
+		roleName:        roleName,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (res *RoleManagerEventStore) RemoveMemberFromAllRoles(ctx context.Context, session authn.Session, membersID string) (err error) {
-	return res.svc.RemoveMemberFromAllRoles(ctx, session, membersID)
+func (rmes *RoleManagerEventStore) RemoveMemberFromAllRoles(ctx context.Context, session authn.Session, memberID string) (err error) {
+	if err := rmes.svc.RemoveMemberFromAllRoles(ctx, session, memberID); err != nil {
+		return err
+	}
+
+	e := removeMemberFromAllRolesEvent{
+		operationPrefix: rmes.operationPrefix,
+		memberID:        memberID,
+	}
+	if err := rmes.Publish(ctx, e); err != nil {
+		return err
+	}
+	return nil
 }
diff --git a/pkg/roles/roles.go b/pkg/roles/roles.go
index 3dac377133..c4e11d9007 100644
--- a/pkg/roles/roles.go
+++ b/pkg/roles/roles.go
@@ -146,7 +146,7 @@ type Repository interface {
 	RoleRemoveMembers(ctx context.Context, role Role, members []string) (err error)
 	RoleRemoveAllMembers(ctx context.Context, role Role) (err error)
 	RetrieveEntitiesRolesActionsMembers(ctx context.Context, entityIDs []string) ([]EntityActionRole, []EntityMemberRole, error)
-	RemoveMemberFromAllRoles(ctx context.Context, members string) (err error)
+	RemoveMemberFromAllRoles(ctx context.Context, memberID string) (err error)
 }
 
 type Roles interface {