MM-56879: Migrate caches from store layer to cache layer (#26255)

There were 3 remaining caches which were there in the store layer. We migrate them to make the store layer fully free from any caches. https://mattermost.atlassian.net/browse/MM-56879 ```release-note NONE ``` Co-authored-by: Mattermost Build <build@mattermost.com>
2024-03-07 10:55:28 +05:30
--- a/server/channels/store/localcachelayer/channel_layer.go
+++ b/server/channels/store/localcachelayer/channel_layer.go
@@ -48,48 +48,111 @@ func (s *LocalCacheChannelStore) handleClusterInvalidateChannelById(msg *model.C
 	}
 }

+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelForUser(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelMembersForUserCache.Purge()
+	} else {
+		s.rootStore.channelMembersForUserCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelMembersNotifyProps(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelMembersNotifyPropsCache.Purge()
+	} else {
+		s.rootStore.channelMembersNotifyPropsCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelByName(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelByNameCache.Purge()
+	} else {
+		s.rootStore.channelByNameCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheChannelStore) ClearMembersForUserCache() {
+	s.rootStore.doClearCacheCluster(s.rootStore.channelMembersForUserCache)
+}
+
 func (s LocalCacheChannelStore) ClearCaches() {
 	s.rootStore.doClearCacheCluster(s.rootStore.channelMemberCountsCache)
 	s.rootStore.doClearCacheCluster(s.rootStore.channelPinnedPostCountsCache)
 	s.rootStore.doClearCacheCluster(s.rootStore.channelGuestCountCache)
 	s.rootStore.doClearCacheCluster(s.rootStore.channelByIdCache)
-	s.ChannelStore.ClearCaches()
+	s.rootStore.doClearCacheCluster(s.rootStore.channelMembersForUserCache)
+	s.rootStore.doClearCacheCluster(s.rootStore.channelMembersNotifyPropsCache)
+	s.rootStore.doClearCacheCluster(s.rootStore.channelByNameCache)
 	if s.rootStore.metrics != nil {
-		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Pinned Post Counts - Purge")
-		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Member Counts - Purge")
-		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Guest Count - Purge")
-		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel - Purge")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelMemberCountsCache.Name())
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelPinnedPostCountsCache.Name())
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelGuestCountCache.Name())
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelByIdCache.Name())
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelMembersForUserCache.Name())
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelMembersNotifyPropsCache.Name())
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelByNameCache.Name())
 	}
 }

 func (s LocalCacheChannelStore) InvalidatePinnedPostCount(channelId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelPinnedPostCountsCache, channelId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelPinnedPostCountsCache, channelId, nil)
 	if s.rootStore.metrics != nil {
-		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Pinned Post Counts - Remove by ChannelId")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelPinnedPostCountsCache.Name())
 	}
 }

 func (s LocalCacheChannelStore) InvalidateMemberCount(channelId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelMemberCountsCache, channelId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelMemberCountsCache, channelId, nil)
 	if s.rootStore.metrics != nil {
-		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Member Counts - Remove by ChannelId")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelMemberCountsCache.Name())
 	}
 }

 func (s LocalCacheChannelStore) InvalidateGuestCount(channelId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelGuestCountCache, channelId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelGuestCountCache, channelId, nil)
 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Guests Count - Remove by channelId")
 	}
 }

 func (s LocalCacheChannelStore) InvalidateChannel(channelId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelByIdCache, channelId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelByIdCache, channelId, nil)
 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel - Remove by ChannelId")
 	}
 }

+func (s LocalCacheChannelStore) InvalidateAllChannelMembersForUser(userId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelMembersForUserCache, userId, nil)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelMembersForUserCache, userId+"_deleted", nil)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelMembersForUserCache.Name())
+	}
+}
+
+func (s LocalCacheChannelStore) InvalidateCacheForChannelMembersNotifyProps(channelId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelMembersNotifyPropsCache, channelId, nil)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelMembersNotifyPropsCache.Name())
+	}
+}
+
+func (s LocalCacheChannelStore) InvalidateChannelByName(teamId, name string) {
+	props := make(map[string]string)
+	props["name"] = name
+	if teamId == "" {
+		props["id"] = "dm"
+	} else {
+		props["id"] = teamId
+	}
+
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelByNameCache, teamId+name, props)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter(s.rootStore.channelByNameCache.Name())
+	}
+}
+
 func (s LocalCacheChannelStore) GetMemberCount(channelId string, allowFromCache bool) (int64, error) {
 	if allowFromCache {
 		var count int64
@@ -205,6 +268,141 @@ func (s LocalCacheChannelStore) GetMany(ids []string, allowFromCache bool) (mode
 	return append(foundChannels, channels...), nil
 }

+func (s LocalCacheChannelStore) GetAllChannelMembersForUser(userId string, allowFromCache bool, includeDeleted bool) (map[string]string, error) {
+	cache_key := userId
+	if includeDeleted {
+		cache_key += "_deleted"
+	}
+	if allowFromCache {
+		ids := make(map[string]string)
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelMembersForUserCache, cache_key, &ids); err == nil {
+			return ids, nil
+		}
+	}
+
+	ids, err := s.ChannelStore.GetAllChannelMembersForUser(userId, allowFromCache, includeDeleted)
+	if err != nil {
+		return nil, err
+	}
+
+	if allowFromCache {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelMembersForUserCache, cache_key, ids)
+	}
+
+	return ids, nil
+}
+
+func (s LocalCacheChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelId string, allowFromCache bool) (map[string]model.StringMap, error) {
+	if allowFromCache {
+		var cacheItem map[string]model.StringMap
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelMembersNotifyPropsCache, channelId, &cacheItem); err == nil {
+			return cacheItem, nil
+		}
+	}
+
+	props, err := s.ChannelStore.GetAllChannelMembersNotifyPropsForChannel(channelId, allowFromCache)
+	if err != nil {
+		return nil, err
+	}
+
+	if allowFromCache {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelMembersNotifyPropsCache, channelId, props)
+	}
+
+	return props, nil
+}
+
+func (s LocalCacheChannelStore) GetByNamesIncludeDeleted(teamId string, names []string, allowFromCache bool) ([]*model.Channel, error) {
+	return s.getByNames(teamId, names, allowFromCache, true)
+}
+
+func (s LocalCacheChannelStore) GetByNames(teamId string, names []string, allowFromCache bool) ([]*model.Channel, error) {
+	return s.getByNames(teamId, names, allowFromCache, false)
+}
+
+func (s LocalCacheChannelStore) getByNames(teamId string, names []string, allowFromCache, includeArchivedChannels bool) ([]*model.Channel, error) {
+	var channels []*model.Channel
+
+	if allowFromCache {
+		var misses []string
+		visited := make(map[string]struct{})
+		for _, name := range names {
+			if _, ok := visited[name]; ok {
+				continue
+			}
+			visited[name] = struct{}{}
+			var cacheItem *model.Channel
+
+			if err := s.rootStore.doStandardReadCache(s.rootStore.channelByNameCache, teamId+name, &cacheItem); err == nil {
+				if includeArchivedChannels || cacheItem.DeleteAt == 0 {
+					channels = append(channels, cacheItem)
+				}
+			} else {
+				misses = append(misses, name)
+			}
+		}
+		names = misses
+	}
+
+	if len(names) > 0 {
+		var dbChannels []*model.Channel
+		var err error
+		if includeArchivedChannels {
+			dbChannels, err = s.ChannelStore.GetByNamesIncludeDeleted(teamId, names, allowFromCache)
+		} else {
+			dbChannels, err = s.ChannelStore.GetByNames(teamId, names, allowFromCache)
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		for _, channel := range dbChannels {
+			if allowFromCache {
+				s.rootStore.doStandardAddToCache(s.rootStore.channelByNameCache, teamId+channel.Name, channel)
+			}
+			channels = append(channels, channel)
+		}
+	}
+
+	return channels, nil
+}
+
+func (s LocalCacheChannelStore) GetByNameIncludeDeleted(teamId string, name string, allowFromCache bool) (*model.Channel, error) {
+	return s.getByName(teamId, name, allowFromCache, true)
+}
+
+func (s LocalCacheChannelStore) GetByName(teamId string, name string, allowFromCache bool) (*model.Channel, error) {
+	return s.getByName(teamId, name, allowFromCache, false)
+}
+
+func (s LocalCacheChannelStore) getByName(teamId string, name string, allowFromCache, includeArchivedChannels bool) (*model.Channel, error) {
+	var channel *model.Channel
+
+	if allowFromCache {
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelByNameCache, teamId+name, &channel); err == nil {
+			if includeArchivedChannels || channel.DeleteAt == 0 {
+				return channel, nil
+			}
+		}
+	}
+
+	var err error
+	if includeArchivedChannels {
+		channel, err = s.ChannelStore.GetByNameIncludeDeleted(teamId, name, allowFromCache)
+	} else {
+		channel, err = s.ChannelStore.GetByName(teamId, name, allowFromCache)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	if allowFromCache {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelByNameCache, teamId+name, channel)
+	}
+
+	return channel, nil
+}
+
 func (s LocalCacheChannelStore) SaveMember(rctx request.CTX, member *model.ChannelMember) (*model.ChannelMember, error) {
 	member, err := s.ChannelStore.SaveMember(rctx, member)
 	if err != nil {
--- a/server/channels/store/localcachelayer/emoji_layer.go
+++ b/server/channels/store/localcachelayer/emoji_layer.go
@@ -171,10 +171,10 @@ func (es *LocalCacheEmojiStore) removeFromCache(emoji *model.Emoji) {
 	es.emojiByIdMut.Lock()
 	es.emojiByIdInvalidations[emoji.Id] = true
 	es.emojiByIdMut.Unlock()
-	es.rootStore.doInvalidateCacheCluster(es.rootStore.emojiCacheById, emoji.Id)
+	es.rootStore.doInvalidateCacheCluster(es.rootStore.emojiCacheById, emoji.Id, nil)

 	es.emojiByNameMut.Lock()
 	es.emojiByNameInvalidations[emoji.Name] = true
 	es.emojiByNameMut.Unlock()
-	es.rootStore.doInvalidateCacheCluster(es.rootStore.emojiIdCacheByName, emoji.Name)
+	es.rootStore.doInvalidateCacheCluster(es.rootStore.emojiIdCacheByName, emoji.Name, nil)
 }
--- a/server/channels/store/localcachelayer/file_info_layer.go
+++ b/server/channels/store/localcachelayer/file_info_layer.go
@@ -62,7 +62,7 @@ func (s LocalCacheFileInfoStore) InvalidateFileInfosForPostCache(postId string,
 	if deleted {
 		cacheKey += "_deleted"
 	}
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.fileInfoCache, cacheKey)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.fileInfoCache, cacheKey, nil)
 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("File Info Cache - Remove by PostId")
 	}
--- a/server/channels/store/localcachelayer/layer.go
+++ b/server/channels/store/localcachelayer/layer.go
@@ -35,8 +35,15 @@ const (
 	EmojiCacheSize = 5000
 	EmojiCacheSec  = 30 * 60

-	ChannelPinnedPostsCountsCacheSize = model.ChannelCacheSize
-	ChannelPinnedPostsCountsCacheSec  = 30 * 60
+	ChannelPinnedPostsCountsCacheSize     = model.ChannelCacheSize
+	ChannelPinnedPostsCountsCacheSec      = 30 * 60
+	AllChannelMembersForUserCacheSize     = model.SessionCacheSize
+	AllChannelMembersForUserCacheDuration = 15 * time.Minute
+
+	AllChannelMembersNotifyPropsForChannelCacheSize     = model.SessionCacheSize
+	AllChannelMembersNotifyPropsForChannelCacheDuration = 30 * time.Minute
+
+	ChannelCacheDuration = 15 * time.Minute

 	ChannelMembersCountsCacheSize = model.ChannelCacheSize
 	ChannelMembersCountsCacheSec  = 30 * 60
@@ -87,11 +94,14 @@ type LocalCacheStore struct {
 	emojiCacheById     cache.Cache
 	emojiIdCacheByName cache.Cache

-	channel                      LocalCacheChannelStore
-	channelMemberCountsCache     cache.Cache
-	channelGuestCountCache       cache.Cache
-	channelPinnedPostCountsCache cache.Cache
-	channelByIdCache             cache.Cache
+	channel                        LocalCacheChannelStore
+	channelMemberCountsCache       cache.Cache
+	channelGuestCountCache         cache.Cache
+	channelPinnedPostCountsCache   cache.Cache
+	channelByIdCache               cache.Cache
+	channelMembersForUserCache     cache.Cache
+	channelMembersNotifyPropsCache cache.Cache
+	channelByNameCache             cache.Cache

 	webhook      LocalCacheWebhookStore
 	webhookCache cache.Cache
@@ -240,6 +250,30 @@ func NewLocalCacheLayer(baseStore store.Store, metrics einterfaces.MetricsInterf
 	}); err != nil {
 		return
 	}
+	if localCacheStore.channelMembersForUserCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   AllChannelMembersForUserCacheSize,
+		Name:                   "ChannnelMembersForUser",
+		DefaultExpiry:          AllChannelMembersForUserCacheDuration,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForUser,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.channelMembersNotifyPropsCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   AllChannelMembersNotifyPropsForChannelCacheSize,
+		Name:                   "ChannnelMembersNotifyProps",
+		DefaultExpiry:          AllChannelMembersNotifyPropsForChannelCacheDuration,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForChannelMembersNotifyProps,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.channelByNameCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   model.ChannelCacheSize,
+		Name:                   "ChannelByName",
+		DefaultExpiry:          ChannelCacheDuration,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForChannelByName,
+	}); err != nil {
+		return
+	}
 	localCacheStore.channel = LocalCacheChannelStore{ChannelStore: baseStore.Channel(), rootStore: &localCacheStore}

 	// Posts
@@ -331,6 +365,9 @@ func NewLocalCacheLayer(baseStore store.Store, metrics einterfaces.MetricsInterf
 		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelMemberCounts, localCacheStore.channel.handleClusterInvalidateChannelMemberCounts)
 		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelGuestCount, localCacheStore.channel.handleClusterInvalidateChannelGuestCounts)
 		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannel, localCacheStore.channel.handleClusterInvalidateChannelById)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForUser, localCacheStore.channel.handleClusterInvalidateChannelForUser)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelMembersNotifyProps, localCacheStore.channel.handleClusterInvalidateChannelMembersNotifyProps)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelByName, localCacheStore.channel.handleClusterInvalidateChannelByName)
 		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForLastPosts, localCacheStore.post.handleClusterInvalidateLastPosts)
 		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForTermsOfService, localCacheStore.termsOfService.handleClusterInvalidateTermsOfService)
 		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForProfileByIds, localCacheStore.user.handleClusterInvalidateScheme)
@@ -396,7 +433,7 @@ func (s LocalCacheStore) DropAllTables() {
 	s.Store.DropAllTables()
 }

-func (s *LocalCacheStore) doInvalidateCacheCluster(cache cache.Cache, key string) {
+func (s *LocalCacheStore) doInvalidateCacheCluster(cache cache.Cache, key string, props map[string]string) {
 	cache.Remove(key)
 	if s.cluster != nil {
 		msg := &model.ClusterMessage{
@@ -404,6 +441,9 @@ func (s *LocalCacheStore) doInvalidateCacheCluster(cache cache.Cache, key string
 			SendType: model.ClusterSendBestEffort,
 			Data:     []byte(key),
 		}
+		if props != nil {
+			msg.Props = props
+		}
 		s.cluster.SendClusterMessage(msg)
 	}
 }
@@ -450,6 +490,9 @@ func (s *LocalCacheStore) Invalidate() {
 	s.doClearCacheCluster(s.channelPinnedPostCountsCache)
 	s.doClearCacheCluster(s.channelGuestCountCache)
 	s.doClearCacheCluster(s.channelByIdCache)
+	s.doClearCacheCluster(s.channelMembersForUserCache)
+	s.doClearCacheCluster(s.channelMembersNotifyPropsCache)
+	s.doClearCacheCluster(s.channelByNameCache)
 	s.doClearCacheCluster(s.postLastPostsCache)
 	s.doClearCacheCluster(s.termsOfServiceCache)
 	s.doClearCacheCluster(s.lastPostTimeCache)
--- a/server/channels/store/localcachelayer/post_layer.go
+++ b/server/channels/store/localcachelayer/post_layer.go
@@ -56,11 +56,11 @@ func (s LocalCachePostStore) ClearCaches() {
 }

 func (s LocalCachePostStore) InvalidateLastPostTimeCache(channelId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.lastPostTimeCache, channelId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.lastPostTimeCache, channelId, nil)

 	// Keys are "{channelid}{limit}" and caching only occurs on limits of 30 and 60
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.postLastPostsCache, channelId+"30")
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.postLastPostsCache, channelId+"60")
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.postLastPostsCache, channelId+"30", nil)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.postLastPostsCache, channelId+"60", nil)

 	s.PostStore.InvalidateLastPostTimeCache(channelId)

--- a/server/channels/store/localcachelayer/reaction_layer.go
+++ b/server/channels/store/localcachelayer/reaction_layer.go
@@ -24,12 +24,12 @@ func (s *LocalCacheReactionStore) handleClusterInvalidateReaction(msg *model.Clu
 }

 func (s LocalCacheReactionStore) Save(reaction *model.Reaction) (*model.Reaction, error) {
-	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.reactionCache, reaction.PostId)
+	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.reactionCache, reaction.PostId, nil)
 	return s.ReactionStore.Save(reaction)
 }

 func (s LocalCacheReactionStore) Delete(reaction *model.Reaction) (*model.Reaction, error) {
-	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.reactionCache, reaction.PostId)
+	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.reactionCache, reaction.PostId, nil)
 	return s.ReactionStore.Delete(reaction)
 }

--- a/server/channels/store/localcachelayer/role_layer.go
+++ b/server/channels/store/localcachelayer/role_layer.go
@@ -36,7 +36,7 @@ func (s *LocalCacheRoleStore) handleClusterInvalidateRolePermissions(msg *model.

 func (s LocalCacheRoleStore) Save(role *model.Role) (*model.Role, error) {
 	if role.Name != "" {
-		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.roleCache, role.Name)
+		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.roleCache, role.Name, nil)
 		defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
 	}
 	return s.RoleStore.Save(role)
@@ -85,7 +85,7 @@ func (s LocalCacheRoleStore) Delete(roleId string) (*model.Role, error) {
 	role, err := s.RoleStore.Delete(roleId)

 	if err == nil {
-		s.rootStore.doInvalidateCacheCluster(s.rootStore.roleCache, role.Name)
+		s.rootStore.doInvalidateCacheCluster(s.rootStore.roleCache, role.Name, nil)
 		defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
 	}
 	return role, err
--- a/server/channels/store/localcachelayer/scheme_layer.go
+++ b/server/channels/store/localcachelayer/scheme_layer.go
@@ -25,7 +25,7 @@ func (s *LocalCacheSchemeStore) handleClusterInvalidateScheme(msg *model.Cluster

 func (s LocalCacheSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
 	if scheme.Id != "" {
-		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, scheme.Id)
+		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, scheme.Id, nil)
 	}
 	return s.SchemeStore.Save(scheme)
 }
@@ -47,7 +47,7 @@ func (s LocalCacheSchemeStore) Get(schemeId string) (*model.Scheme, error) {
 }

 func (s LocalCacheSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
-	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, schemeId)
+	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, schemeId, nil)
 	defer s.rootStore.doClearCacheCluster(s.rootStore.roleCache)
 	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
 	return s.SchemeStore.Delete(schemeId)
--- a/server/channels/store/localcachelayer/team_layer.go
+++ b/server/channels/store/localcachelayer/team_layer.go
@@ -31,7 +31,7 @@ func (s LocalCacheTeamStore) ClearCaches() {
 }

 func (s LocalCacheTeamStore) InvalidateAllTeamIdsForUser(userId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.teamAllTeamIdsForUserCache, userId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.teamAllTeamIdsForUserCache, userId, nil)
 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("All Team Ids for User - Remove by UserId")
 	}
--- a/server/channels/store/localcachelayer/terms_of_service_layer.go
+++ b/server/channels/store/localcachelayer/terms_of_service_layer.go
@@ -40,7 +40,7 @@ func (s LocalCacheTermsOfServiceStore) Save(termsOfService *model.TermsOfService

 	if err == nil {
 		s.rootStore.doStandardAddToCache(s.rootStore.termsOfServiceCache, tos.Id, tos)
-		s.rootStore.doInvalidateCacheCluster(s.rootStore.termsOfServiceCache, LatestKey)
+		s.rootStore.doInvalidateCacheCluster(s.rootStore.termsOfServiceCache, LatestKey, nil)
 	}
 	return tos, err
 }
--- a/server/channels/store/localcachelayer/user_layer.go
+++ b/server/channels/store/localcachelayer/user_layer.go
@@ -54,7 +54,7 @@ func (s *LocalCacheUserStore) InvalidateProfileCacheForUser(userId string) {
 	s.userProfileByIdsMut.Lock()
 	s.userProfileByIdsInvalidations[userId] = true
 	s.userProfileByIdsMut.Unlock()
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.userProfileByIdsCache, userId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.userProfileByIdsCache, userId, nil)

 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profile By Ids - Remove")
@@ -68,7 +68,7 @@ func (s *LocalCacheUserStore) InvalidateProfilesInChannelCacheByUser(userId stri
 			var userMap map[string]*model.User
 			if err = s.rootStore.profilesInChannelCache.Get(key, &userMap); err == nil {
 				if _, userInCache := userMap[userId]; userInCache {
-					s.rootStore.doInvalidateCacheCluster(s.rootStore.profilesInChannelCache, key)
+					s.rootStore.doInvalidateCacheCluster(s.rootStore.profilesInChannelCache, key, nil)
 					if s.rootStore.metrics != nil {
 						s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profiles in Channel - Remove by User")
 					}
@@ -79,7 +79,7 @@ func (s *LocalCacheUserStore) InvalidateProfilesInChannelCacheByUser(userId stri
 }

 func (s *LocalCacheUserStore) InvalidateProfilesInChannelCache(channelID string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.profilesInChannelCache, channelID)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.profilesInChannelCache, channelID, nil)
 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profiles in Channel - Remove by Channel")
 	}
--- a/server/channels/store/localcachelayer/webhook_layer.go
+++ b/server/channels/store/localcachelayer/webhook_layer.go
@@ -32,7 +32,7 @@ func (s LocalCacheWebhookStore) ClearCaches() {
 }

 func (s LocalCacheWebhookStore) InvalidateWebhookCache(webhookId string) {
-	s.rootStore.doInvalidateCacheCluster(s.rootStore.webhookCache, webhookId)
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.webhookCache, webhookId, nil)
 	if s.rootStore.metrics != nil {
 		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Webhook - Remove by WebhookId")
 	}