github.com/haalcala/mattermost-server-change-repo@v0.0.0-20210713015153-16753fbeee5f/store/timerlayer/timerlayer.go (about)

     1  // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
     2  // See LICENSE.txt for license information.
     3  
     4  // Code generated by "make store-layers"
     5  // DO NOT EDIT
     6  
     7  package timerlayer
     8  
     9  import (
    10  	"context"
    11  	timemodule "time"
    12  
    13  	"github.com/mattermost/mattermost-server/v5/einterfaces"
    14  	"github.com/mattermost/mattermost-server/v5/model"
    15  	"github.com/mattermost/mattermost-server/v5/store"
    16  )
    17  
    18  type TimerLayer struct {
    19  	store.Store
    20  	Metrics                   einterfaces.MetricsInterface
    21  	AuditStore                store.AuditStore
    22  	BotStore                  store.BotStore
    23  	ChannelStore              store.ChannelStore
    24  	ChannelMemberHistoryStore store.ChannelMemberHistoryStore
    25  	ClusterDiscoveryStore     store.ClusterDiscoveryStore
    26  	CommandStore              store.CommandStore
    27  	CommandWebhookStore       store.CommandWebhookStore
    28  	ComplianceStore           store.ComplianceStore
    29  	EmojiStore                store.EmojiStore
    30  	FileInfoStore             store.FileInfoStore
    31  	GroupStore                store.GroupStore
    32  	JobStore                  store.JobStore
    33  	LicenseStore              store.LicenseStore
    34  	LinkMetadataStore         store.LinkMetadataStore
    35  	OAuthStore                store.OAuthStore
    36  	PluginStore               store.PluginStore
    37  	PostStore                 store.PostStore
    38  	PreferenceStore           store.PreferenceStore
    39  	ProductNoticesStore       store.ProductNoticesStore
    40  	ReactionStore             store.ReactionStore
    41  	RoleStore                 store.RoleStore
    42  	SchemeStore               store.SchemeStore
    43  	SessionStore              store.SessionStore
    44  	StatusStore               store.StatusStore
    45  	SystemStore               store.SystemStore
    46  	TeamStore                 store.TeamStore
    47  	TermsOfServiceStore       store.TermsOfServiceStore
    48  	ThreadStore               store.ThreadStore
    49  	TokenStore                store.TokenStore
    50  	UploadSessionStore        store.UploadSessionStore
    51  	UserStore                 store.UserStore
    52  	UserAccessTokenStore      store.UserAccessTokenStore
    53  	UserTermsOfServiceStore   store.UserTermsOfServiceStore
    54  	WebhookStore              store.WebhookStore
    55  }
    56  
    57  func (s *TimerLayer) Audit() store.AuditStore {
    58  	return s.AuditStore
    59  }
    60  
    61  func (s *TimerLayer) Bot() store.BotStore {
    62  	return s.BotStore
    63  }
    64  
    65  func (s *TimerLayer) Channel() store.ChannelStore {
    66  	return s.ChannelStore
    67  }
    68  
    69  func (s *TimerLayer) ChannelMemberHistory() store.ChannelMemberHistoryStore {
    70  	return s.ChannelMemberHistoryStore
    71  }
    72  
    73  func (s *TimerLayer) ClusterDiscovery() store.ClusterDiscoveryStore {
    74  	return s.ClusterDiscoveryStore
    75  }
    76  
    77  func (s *TimerLayer) Command() store.CommandStore {
    78  	return s.CommandStore
    79  }
    80  
    81  func (s *TimerLayer) CommandWebhook() store.CommandWebhookStore {
    82  	return s.CommandWebhookStore
    83  }
    84  
    85  func (s *TimerLayer) Compliance() store.ComplianceStore {
    86  	return s.ComplianceStore
    87  }
    88  
    89  func (s *TimerLayer) Emoji() store.EmojiStore {
    90  	return s.EmojiStore
    91  }
    92  
    93  func (s *TimerLayer) FileInfo() store.FileInfoStore {
    94  	return s.FileInfoStore
    95  }
    96  
    97  func (s *TimerLayer) Group() store.GroupStore {
    98  	return s.GroupStore
    99  }
   100  
   101  func (s *TimerLayer) Job() store.JobStore {
   102  	return s.JobStore
   103  }
   104  
   105  func (s *TimerLayer) License() store.LicenseStore {
   106  	return s.LicenseStore
   107  }
   108  
   109  func (s *TimerLayer) LinkMetadata() store.LinkMetadataStore {
   110  	return s.LinkMetadataStore
   111  }
   112  
   113  func (s *TimerLayer) OAuth() store.OAuthStore {
   114  	return s.OAuthStore
   115  }
   116  
   117  func (s *TimerLayer) Plugin() store.PluginStore {
   118  	return s.PluginStore
   119  }
   120  
   121  func (s *TimerLayer) Post() store.PostStore {
   122  	return s.PostStore
   123  }
   124  
   125  func (s *TimerLayer) Preference() store.PreferenceStore {
   126  	return s.PreferenceStore
   127  }
   128  
   129  func (s *TimerLayer) ProductNotices() store.ProductNoticesStore {
   130  	return s.ProductNoticesStore
   131  }
   132  
   133  func (s *TimerLayer) Reaction() store.ReactionStore {
   134  	return s.ReactionStore
   135  }
   136  
   137  func (s *TimerLayer) Role() store.RoleStore {
   138  	return s.RoleStore
   139  }
   140  
   141  func (s *TimerLayer) Scheme() store.SchemeStore {
   142  	return s.SchemeStore
   143  }
   144  
   145  func (s *TimerLayer) Session() store.SessionStore {
   146  	return s.SessionStore
   147  }
   148  
   149  func (s *TimerLayer) Status() store.StatusStore {
   150  	return s.StatusStore
   151  }
   152  
   153  func (s *TimerLayer) System() store.SystemStore {
   154  	return s.SystemStore
   155  }
   156  
   157  func (s *TimerLayer) Team() store.TeamStore {
   158  	return s.TeamStore
   159  }
   160  
   161  func (s *TimerLayer) TermsOfService() store.TermsOfServiceStore {
   162  	return s.TermsOfServiceStore
   163  }
   164  
   165  func (s *TimerLayer) Thread() store.ThreadStore {
   166  	return s.ThreadStore
   167  }
   168  
   169  func (s *TimerLayer) Token() store.TokenStore {
   170  	return s.TokenStore
   171  }
   172  
   173  func (s *TimerLayer) UploadSession() store.UploadSessionStore {
   174  	return s.UploadSessionStore
   175  }
   176  
   177  func (s *TimerLayer) User() store.UserStore {
   178  	return s.UserStore
   179  }
   180  
   181  func (s *TimerLayer) UserAccessToken() store.UserAccessTokenStore {
   182  	return s.UserAccessTokenStore
   183  }
   184  
   185  func (s *TimerLayer) UserTermsOfService() store.UserTermsOfServiceStore {
   186  	return s.UserTermsOfServiceStore
   187  }
   188  
   189  func (s *TimerLayer) Webhook() store.WebhookStore {
   190  	return s.WebhookStore
   191  }
   192  
   193  type TimerLayerAuditStore struct {
   194  	store.AuditStore
   195  	Root *TimerLayer
   196  }
   197  
   198  type TimerLayerBotStore struct {
   199  	store.BotStore
   200  	Root *TimerLayer
   201  }
   202  
   203  type TimerLayerChannelStore struct {
   204  	store.ChannelStore
   205  	Root *TimerLayer
   206  }
   207  
   208  type TimerLayerChannelMemberHistoryStore struct {
   209  	store.ChannelMemberHistoryStore
   210  	Root *TimerLayer
   211  }
   212  
   213  type TimerLayerClusterDiscoveryStore struct {
   214  	store.ClusterDiscoveryStore
   215  	Root *TimerLayer
   216  }
   217  
   218  type TimerLayerCommandStore struct {
   219  	store.CommandStore
   220  	Root *TimerLayer
   221  }
   222  
   223  type TimerLayerCommandWebhookStore struct {
   224  	store.CommandWebhookStore
   225  	Root *TimerLayer
   226  }
   227  
   228  type TimerLayerComplianceStore struct {
   229  	store.ComplianceStore
   230  	Root *TimerLayer
   231  }
   232  
   233  type TimerLayerEmojiStore struct {
   234  	store.EmojiStore
   235  	Root *TimerLayer
   236  }
   237  
   238  type TimerLayerFileInfoStore struct {
   239  	store.FileInfoStore
   240  	Root *TimerLayer
   241  }
   242  
   243  type TimerLayerGroupStore struct {
   244  	store.GroupStore
   245  	Root *TimerLayer
   246  }
   247  
   248  type TimerLayerJobStore struct {
   249  	store.JobStore
   250  	Root *TimerLayer
   251  }
   252  
   253  type TimerLayerLicenseStore struct {
   254  	store.LicenseStore
   255  	Root *TimerLayer
   256  }
   257  
   258  type TimerLayerLinkMetadataStore struct {
   259  	store.LinkMetadataStore
   260  	Root *TimerLayer
   261  }
   262  
   263  type TimerLayerOAuthStore struct {
   264  	store.OAuthStore
   265  	Root *TimerLayer
   266  }
   267  
   268  type TimerLayerPluginStore struct {
   269  	store.PluginStore
   270  	Root *TimerLayer
   271  }
   272  
   273  type TimerLayerPostStore struct {
   274  	store.PostStore
   275  	Root *TimerLayer
   276  }
   277  
   278  type TimerLayerPreferenceStore struct {
   279  	store.PreferenceStore
   280  	Root *TimerLayer
   281  }
   282  
   283  type TimerLayerProductNoticesStore struct {
   284  	store.ProductNoticesStore
   285  	Root *TimerLayer
   286  }
   287  
   288  type TimerLayerReactionStore struct {
   289  	store.ReactionStore
   290  	Root *TimerLayer
   291  }
   292  
   293  type TimerLayerRoleStore struct {
   294  	store.RoleStore
   295  	Root *TimerLayer
   296  }
   297  
   298  type TimerLayerSchemeStore struct {
   299  	store.SchemeStore
   300  	Root *TimerLayer
   301  }
   302  
   303  type TimerLayerSessionStore struct {
   304  	store.SessionStore
   305  	Root *TimerLayer
   306  }
   307  
   308  type TimerLayerStatusStore struct {
   309  	store.StatusStore
   310  	Root *TimerLayer
   311  }
   312  
   313  type TimerLayerSystemStore struct {
   314  	store.SystemStore
   315  	Root *TimerLayer
   316  }
   317  
   318  type TimerLayerTeamStore struct {
   319  	store.TeamStore
   320  	Root *TimerLayer
   321  }
   322  
   323  type TimerLayerTermsOfServiceStore struct {
   324  	store.TermsOfServiceStore
   325  	Root *TimerLayer
   326  }
   327  
   328  type TimerLayerThreadStore struct {
   329  	store.ThreadStore
   330  	Root *TimerLayer
   331  }
   332  
   333  type TimerLayerTokenStore struct {
   334  	store.TokenStore
   335  	Root *TimerLayer
   336  }
   337  
   338  type TimerLayerUploadSessionStore struct {
   339  	store.UploadSessionStore
   340  	Root *TimerLayer
   341  }
   342  
   343  type TimerLayerUserStore struct {
   344  	store.UserStore
   345  	Root *TimerLayer
   346  }
   347  
   348  type TimerLayerUserAccessTokenStore struct {
   349  	store.UserAccessTokenStore
   350  	Root *TimerLayer
   351  }
   352  
   353  type TimerLayerUserTermsOfServiceStore struct {
   354  	store.UserTermsOfServiceStore
   355  	Root *TimerLayer
   356  }
   357  
   358  type TimerLayerWebhookStore struct {
   359  	store.WebhookStore
   360  	Root *TimerLayer
   361  }
   362  
   363  func (s *TimerLayerAuditStore) Get(user_id string, offset int, limit int) (model.Audits, error) {
   364  	start := timemodule.Now()
   365  
   366  	result, err := s.AuditStore.Get(user_id, offset, limit)
   367  
   368  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   369  	if s.Root.Metrics != nil {
   370  		success := "false"
   371  		if err == nil {
   372  			success = "true"
   373  		}
   374  		s.Root.Metrics.ObserveStoreMethodDuration("AuditStore.Get", success, elapsed)
   375  	}
   376  	return result, err
   377  }
   378  
   379  func (s *TimerLayerAuditStore) PermanentDeleteByUser(userId string) error {
   380  	start := timemodule.Now()
   381  
   382  	err := s.AuditStore.PermanentDeleteByUser(userId)
   383  
   384  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   385  	if s.Root.Metrics != nil {
   386  		success := "false"
   387  		if err == nil {
   388  			success = "true"
   389  		}
   390  		s.Root.Metrics.ObserveStoreMethodDuration("AuditStore.PermanentDeleteByUser", success, elapsed)
   391  	}
   392  	return err
   393  }
   394  
   395  func (s *TimerLayerAuditStore) Save(audit *model.Audit) error {
   396  	start := timemodule.Now()
   397  
   398  	err := s.AuditStore.Save(audit)
   399  
   400  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   401  	if s.Root.Metrics != nil {
   402  		success := "false"
   403  		if err == nil {
   404  			success = "true"
   405  		}
   406  		s.Root.Metrics.ObserveStoreMethodDuration("AuditStore.Save", success, elapsed)
   407  	}
   408  	return err
   409  }
   410  
   411  func (s *TimerLayerBotStore) Get(userId string, includeDeleted bool) (*model.Bot, error) {
   412  	start := timemodule.Now()
   413  
   414  	result, err := s.BotStore.Get(userId, includeDeleted)
   415  
   416  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   417  	if s.Root.Metrics != nil {
   418  		success := "false"
   419  		if err == nil {
   420  			success = "true"
   421  		}
   422  		s.Root.Metrics.ObserveStoreMethodDuration("BotStore.Get", success, elapsed)
   423  	}
   424  	return result, err
   425  }
   426  
   427  func (s *TimerLayerBotStore) GetAll(options *model.BotGetOptions) ([]*model.Bot, error) {
   428  	start := timemodule.Now()
   429  
   430  	result, err := s.BotStore.GetAll(options)
   431  
   432  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   433  	if s.Root.Metrics != nil {
   434  		success := "false"
   435  		if err == nil {
   436  			success = "true"
   437  		}
   438  		s.Root.Metrics.ObserveStoreMethodDuration("BotStore.GetAll", success, elapsed)
   439  	}
   440  	return result, err
   441  }
   442  
   443  func (s *TimerLayerBotStore) PermanentDelete(userId string) error {
   444  	start := timemodule.Now()
   445  
   446  	err := s.BotStore.PermanentDelete(userId)
   447  
   448  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   449  	if s.Root.Metrics != nil {
   450  		success := "false"
   451  		if err == nil {
   452  			success = "true"
   453  		}
   454  		s.Root.Metrics.ObserveStoreMethodDuration("BotStore.PermanentDelete", success, elapsed)
   455  	}
   456  	return err
   457  }
   458  
   459  func (s *TimerLayerBotStore) Save(bot *model.Bot) (*model.Bot, error) {
   460  	start := timemodule.Now()
   461  
   462  	result, err := s.BotStore.Save(bot)
   463  
   464  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   465  	if s.Root.Metrics != nil {
   466  		success := "false"
   467  		if err == nil {
   468  			success = "true"
   469  		}
   470  		s.Root.Metrics.ObserveStoreMethodDuration("BotStore.Save", success, elapsed)
   471  	}
   472  	return result, err
   473  }
   474  
   475  func (s *TimerLayerBotStore) Update(bot *model.Bot) (*model.Bot, error) {
   476  	start := timemodule.Now()
   477  
   478  	result, err := s.BotStore.Update(bot)
   479  
   480  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   481  	if s.Root.Metrics != nil {
   482  		success := "false"
   483  		if err == nil {
   484  			success = "true"
   485  		}
   486  		s.Root.Metrics.ObserveStoreMethodDuration("BotStore.Update", success, elapsed)
   487  	}
   488  	return result, err
   489  }
   490  
   491  func (s *TimerLayerChannelStore) AnalyticsDeletedTypeCount(teamId string, channelType string) (int64, error) {
   492  	start := timemodule.Now()
   493  
   494  	result, err := s.ChannelStore.AnalyticsDeletedTypeCount(teamId, channelType)
   495  
   496  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   497  	if s.Root.Metrics != nil {
   498  		success := "false"
   499  		if err == nil {
   500  			success = "true"
   501  		}
   502  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.AnalyticsDeletedTypeCount", success, elapsed)
   503  	}
   504  	return result, err
   505  }
   506  
   507  func (s *TimerLayerChannelStore) AnalyticsTypeCount(teamId string, channelType string) (int64, error) {
   508  	start := timemodule.Now()
   509  
   510  	result, err := s.ChannelStore.AnalyticsTypeCount(teamId, channelType)
   511  
   512  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   513  	if s.Root.Metrics != nil {
   514  		success := "false"
   515  		if err == nil {
   516  			success = "true"
   517  		}
   518  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.AnalyticsTypeCount", success, elapsed)
   519  	}
   520  	return result, err
   521  }
   522  
   523  func (s *TimerLayerChannelStore) AutocompleteInTeam(teamId string, term string, includeDeleted bool) (*model.ChannelList, error) {
   524  	start := timemodule.Now()
   525  
   526  	result, err := s.ChannelStore.AutocompleteInTeam(teamId, term, includeDeleted)
   527  
   528  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   529  	if s.Root.Metrics != nil {
   530  		success := "false"
   531  		if err == nil {
   532  			success = "true"
   533  		}
   534  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.AutocompleteInTeam", success, elapsed)
   535  	}
   536  	return result, err
   537  }
   538  
   539  func (s *TimerLayerChannelStore) AutocompleteInTeamForSearch(teamId string, userId string, term string, includeDeleted bool) (*model.ChannelList, error) {
   540  	start := timemodule.Now()
   541  
   542  	result, err := s.ChannelStore.AutocompleteInTeamForSearch(teamId, userId, term, includeDeleted)
   543  
   544  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   545  	if s.Root.Metrics != nil {
   546  		success := "false"
   547  		if err == nil {
   548  			success = "true"
   549  		}
   550  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.AutocompleteInTeamForSearch", success, elapsed)
   551  	}
   552  	return result, err
   553  }
   554  
   555  func (s *TimerLayerChannelStore) ClearAllCustomRoleAssignments() error {
   556  	start := timemodule.Now()
   557  
   558  	err := s.ChannelStore.ClearAllCustomRoleAssignments()
   559  
   560  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   561  	if s.Root.Metrics != nil {
   562  		success := "false"
   563  		if err == nil {
   564  			success = "true"
   565  		}
   566  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.ClearAllCustomRoleAssignments", success, elapsed)
   567  	}
   568  	return err
   569  }
   570  
   571  func (s *TimerLayerChannelStore) ClearCaches() {
   572  	start := timemodule.Now()
   573  
   574  	s.ChannelStore.ClearCaches()
   575  
   576  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   577  	if s.Root.Metrics != nil {
   578  		success := "false"
   579  		if true {
   580  			success = "true"
   581  		}
   582  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.ClearCaches", success, elapsed)
   583  	}
   584  }
   585  
   586  func (s *TimerLayerChannelStore) ClearSidebarOnTeamLeave(userId string, teamId string) error {
   587  	start := timemodule.Now()
   588  
   589  	err := s.ChannelStore.ClearSidebarOnTeamLeave(userId, teamId)
   590  
   591  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   592  	if s.Root.Metrics != nil {
   593  		success := "false"
   594  		if err == nil {
   595  			success = "true"
   596  		}
   597  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.ClearSidebarOnTeamLeave", success, elapsed)
   598  	}
   599  	return err
   600  }
   601  
   602  func (s *TimerLayerChannelStore) CountPostsAfter(channelId string, timestamp int64, userId string) (int, error) {
   603  	start := timemodule.Now()
   604  
   605  	result, err := s.ChannelStore.CountPostsAfter(channelId, timestamp, userId)
   606  
   607  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   608  	if s.Root.Metrics != nil {
   609  		success := "false"
   610  		if err == nil {
   611  			success = "true"
   612  		}
   613  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.CountPostsAfter", success, elapsed)
   614  	}
   615  	return result, err
   616  }
   617  
   618  func (s *TimerLayerChannelStore) CreateDirectChannel(userId *model.User, otherUserId *model.User) (*model.Channel, error) {
   619  	start := timemodule.Now()
   620  
   621  	result, err := s.ChannelStore.CreateDirectChannel(userId, otherUserId)
   622  
   623  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   624  	if s.Root.Metrics != nil {
   625  		success := "false"
   626  		if err == nil {
   627  			success = "true"
   628  		}
   629  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.CreateDirectChannel", success, elapsed)
   630  	}
   631  	return result, err
   632  }
   633  
   634  func (s *TimerLayerChannelStore) CreateInitialSidebarCategories(userId string, teamId string) error {
   635  	start := timemodule.Now()
   636  
   637  	err := s.ChannelStore.CreateInitialSidebarCategories(userId, teamId)
   638  
   639  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   640  	if s.Root.Metrics != nil {
   641  		success := "false"
   642  		if err == nil {
   643  			success = "true"
   644  		}
   645  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.CreateInitialSidebarCategories", success, elapsed)
   646  	}
   647  	return err
   648  }
   649  
   650  func (s *TimerLayerChannelStore) CreateSidebarCategory(userId string, teamId string, newCategory *model.SidebarCategoryWithChannels) (*model.SidebarCategoryWithChannels, error) {
   651  	start := timemodule.Now()
   652  
   653  	result, err := s.ChannelStore.CreateSidebarCategory(userId, teamId, newCategory)
   654  
   655  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   656  	if s.Root.Metrics != nil {
   657  		success := "false"
   658  		if err == nil {
   659  			success = "true"
   660  		}
   661  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.CreateSidebarCategory", success, elapsed)
   662  	}
   663  	return result, err
   664  }
   665  
   666  func (s *TimerLayerChannelStore) Delete(channelId string, time int64) error {
   667  	start := timemodule.Now()
   668  
   669  	err := s.ChannelStore.Delete(channelId, time)
   670  
   671  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   672  	if s.Root.Metrics != nil {
   673  		success := "false"
   674  		if err == nil {
   675  			success = "true"
   676  		}
   677  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.Delete", success, elapsed)
   678  	}
   679  	return err
   680  }
   681  
   682  func (s *TimerLayerChannelStore) DeleteSidebarCategory(categoryId string) error {
   683  	start := timemodule.Now()
   684  
   685  	err := s.ChannelStore.DeleteSidebarCategory(categoryId)
   686  
   687  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   688  	if s.Root.Metrics != nil {
   689  		success := "false"
   690  		if err == nil {
   691  			success = "true"
   692  		}
   693  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.DeleteSidebarCategory", success, elapsed)
   694  	}
   695  	return err
   696  }
   697  
   698  func (s *TimerLayerChannelStore) DeleteSidebarChannelsByPreferences(preferences *model.Preferences) error {
   699  	start := timemodule.Now()
   700  
   701  	err := s.ChannelStore.DeleteSidebarChannelsByPreferences(preferences)
   702  
   703  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   704  	if s.Root.Metrics != nil {
   705  		success := "false"
   706  		if err == nil {
   707  			success = "true"
   708  		}
   709  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.DeleteSidebarChannelsByPreferences", success, elapsed)
   710  	}
   711  	return err
   712  }
   713  
   714  func (s *TimerLayerChannelStore) Get(id string, allowFromCache bool) (*model.Channel, error) {
   715  	start := timemodule.Now()
   716  
   717  	result, err := s.ChannelStore.Get(id, allowFromCache)
   718  
   719  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   720  	if s.Root.Metrics != nil {
   721  		success := "false"
   722  		if err == nil {
   723  			success = "true"
   724  		}
   725  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.Get", success, elapsed)
   726  	}
   727  	return result, err
   728  }
   729  
   730  func (s *TimerLayerChannelStore) GetAll(teamId string) ([]*model.Channel, error) {
   731  	start := timemodule.Now()
   732  
   733  	result, err := s.ChannelStore.GetAll(teamId)
   734  
   735  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   736  	if s.Root.Metrics != nil {
   737  		success := "false"
   738  		if err == nil {
   739  			success = "true"
   740  		}
   741  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAll", success, elapsed)
   742  	}
   743  	return result, err
   744  }
   745  
   746  func (s *TimerLayerChannelStore) GetAllChannelMembersForUser(userId string, allowFromCache bool, includeDeleted bool) (map[string]string, error) {
   747  	start := timemodule.Now()
   748  
   749  	result, err := s.ChannelStore.GetAllChannelMembersForUser(userId, allowFromCache, includeDeleted)
   750  
   751  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   752  	if s.Root.Metrics != nil {
   753  		success := "false"
   754  		if err == nil {
   755  			success = "true"
   756  		}
   757  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAllChannelMembersForUser", success, elapsed)
   758  	}
   759  	return result, err
   760  }
   761  
   762  func (s *TimerLayerChannelStore) GetAllChannelMembersNotifyPropsForChannel(channelId string, allowFromCache bool) (map[string]model.StringMap, error) {
   763  	start := timemodule.Now()
   764  
   765  	result, err := s.ChannelStore.GetAllChannelMembersNotifyPropsForChannel(channelId, allowFromCache)
   766  
   767  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   768  	if s.Root.Metrics != nil {
   769  		success := "false"
   770  		if err == nil {
   771  			success = "true"
   772  		}
   773  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAllChannelMembersNotifyPropsForChannel", success, elapsed)
   774  	}
   775  	return result, err
   776  }
   777  
   778  func (s *TimerLayerChannelStore) GetAllChannels(page int, perPage int, opts store.ChannelSearchOpts) (*model.ChannelListWithTeamData, error) {
   779  	start := timemodule.Now()
   780  
   781  	result, err := s.ChannelStore.GetAllChannels(page, perPage, opts)
   782  
   783  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   784  	if s.Root.Metrics != nil {
   785  		success := "false"
   786  		if err == nil {
   787  			success = "true"
   788  		}
   789  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAllChannels", success, elapsed)
   790  	}
   791  	return result, err
   792  }
   793  
   794  func (s *TimerLayerChannelStore) GetAllChannelsCount(opts store.ChannelSearchOpts) (int64, error) {
   795  	start := timemodule.Now()
   796  
   797  	result, err := s.ChannelStore.GetAllChannelsCount(opts)
   798  
   799  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   800  	if s.Root.Metrics != nil {
   801  		success := "false"
   802  		if err == nil {
   803  			success = "true"
   804  		}
   805  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAllChannelsCount", success, elapsed)
   806  	}
   807  	return result, err
   808  }
   809  
   810  func (s *TimerLayerChannelStore) GetAllChannelsForExportAfter(limit int, afterId string) ([]*model.ChannelForExport, error) {
   811  	start := timemodule.Now()
   812  
   813  	result, err := s.ChannelStore.GetAllChannelsForExportAfter(limit, afterId)
   814  
   815  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   816  	if s.Root.Metrics != nil {
   817  		success := "false"
   818  		if err == nil {
   819  			success = "true"
   820  		}
   821  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAllChannelsForExportAfter", success, elapsed)
   822  	}
   823  	return result, err
   824  }
   825  
   826  func (s *TimerLayerChannelStore) GetAllDirectChannelsForExportAfter(limit int, afterId string) ([]*model.DirectChannelForExport, error) {
   827  	start := timemodule.Now()
   828  
   829  	result, err := s.ChannelStore.GetAllDirectChannelsForExportAfter(limit, afterId)
   830  
   831  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   832  	if s.Root.Metrics != nil {
   833  		success := "false"
   834  		if err == nil {
   835  			success = "true"
   836  		}
   837  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetAllDirectChannelsForExportAfter", success, elapsed)
   838  	}
   839  	return result, err
   840  }
   841  
   842  func (s *TimerLayerChannelStore) GetByName(team_id string, name string, allowFromCache bool) (*model.Channel, error) {
   843  	start := timemodule.Now()
   844  
   845  	result, err := s.ChannelStore.GetByName(team_id, name, allowFromCache)
   846  
   847  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   848  	if s.Root.Metrics != nil {
   849  		success := "false"
   850  		if err == nil {
   851  			success = "true"
   852  		}
   853  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetByName", success, elapsed)
   854  	}
   855  	return result, err
   856  }
   857  
   858  func (s *TimerLayerChannelStore) GetByNameIncludeDeleted(team_id string, name string, allowFromCache bool) (*model.Channel, error) {
   859  	start := timemodule.Now()
   860  
   861  	result, err := s.ChannelStore.GetByNameIncludeDeleted(team_id, name, allowFromCache)
   862  
   863  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   864  	if s.Root.Metrics != nil {
   865  		success := "false"
   866  		if err == nil {
   867  			success = "true"
   868  		}
   869  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetByNameIncludeDeleted", success, elapsed)
   870  	}
   871  	return result, err
   872  }
   873  
   874  func (s *TimerLayerChannelStore) GetByNames(team_id string, names []string, allowFromCache bool) ([]*model.Channel, error) {
   875  	start := timemodule.Now()
   876  
   877  	result, err := s.ChannelStore.GetByNames(team_id, names, allowFromCache)
   878  
   879  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   880  	if s.Root.Metrics != nil {
   881  		success := "false"
   882  		if err == nil {
   883  			success = "true"
   884  		}
   885  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetByNames", success, elapsed)
   886  	}
   887  	return result, err
   888  }
   889  
   890  func (s *TimerLayerChannelStore) GetChannelCounts(teamId string, userId string) (*model.ChannelCounts, error) {
   891  	start := timemodule.Now()
   892  
   893  	result, err := s.ChannelStore.GetChannelCounts(teamId, userId)
   894  
   895  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   896  	if s.Root.Metrics != nil {
   897  		success := "false"
   898  		if err == nil {
   899  			success = "true"
   900  		}
   901  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelCounts", success, elapsed)
   902  	}
   903  	return result, err
   904  }
   905  
   906  func (s *TimerLayerChannelStore) GetChannelMembersForExport(userId string, teamId string) ([]*model.ChannelMemberForExport, error) {
   907  	start := timemodule.Now()
   908  
   909  	result, err := s.ChannelStore.GetChannelMembersForExport(userId, teamId)
   910  
   911  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   912  	if s.Root.Metrics != nil {
   913  		success := "false"
   914  		if err == nil {
   915  			success = "true"
   916  		}
   917  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelMembersForExport", success, elapsed)
   918  	}
   919  	return result, err
   920  }
   921  
   922  func (s *TimerLayerChannelStore) GetChannelMembersTimezones(channelId string) ([]model.StringMap, error) {
   923  	start := timemodule.Now()
   924  
   925  	result, err := s.ChannelStore.GetChannelMembersTimezones(channelId)
   926  
   927  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   928  	if s.Root.Metrics != nil {
   929  		success := "false"
   930  		if err == nil {
   931  			success = "true"
   932  		}
   933  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelMembersTimezones", success, elapsed)
   934  	}
   935  	return result, err
   936  }
   937  
   938  func (s *TimerLayerChannelStore) GetChannelUnread(channelId string, userId string) (*model.ChannelUnread, error) {
   939  	start := timemodule.Now()
   940  
   941  	result, err := s.ChannelStore.GetChannelUnread(channelId, userId)
   942  
   943  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   944  	if s.Root.Metrics != nil {
   945  		success := "false"
   946  		if err == nil {
   947  			success = "true"
   948  		}
   949  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelUnread", success, elapsed)
   950  	}
   951  	return result, err
   952  }
   953  
   954  func (s *TimerLayerChannelStore) GetChannels(teamId string, userId string, includeDeleted bool, lastDeleteAt int) (*model.ChannelList, error) {
   955  	start := timemodule.Now()
   956  
   957  	result, err := s.ChannelStore.GetChannels(teamId, userId, includeDeleted, lastDeleteAt)
   958  
   959  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   960  	if s.Root.Metrics != nil {
   961  		success := "false"
   962  		if err == nil {
   963  			success = "true"
   964  		}
   965  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannels", success, elapsed)
   966  	}
   967  	return result, err
   968  }
   969  
   970  func (s *TimerLayerChannelStore) GetChannelsBatchForIndexing(startTime int64, endTime int64, limit int) ([]*model.Channel, error) {
   971  	start := timemodule.Now()
   972  
   973  	result, err := s.ChannelStore.GetChannelsBatchForIndexing(startTime, endTime, limit)
   974  
   975  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   976  	if s.Root.Metrics != nil {
   977  		success := "false"
   978  		if err == nil {
   979  			success = "true"
   980  		}
   981  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelsBatchForIndexing", success, elapsed)
   982  	}
   983  	return result, err
   984  }
   985  
   986  func (s *TimerLayerChannelStore) GetChannelsByIds(channelIds []string, includeDeleted bool) ([]*model.Channel, error) {
   987  	start := timemodule.Now()
   988  
   989  	result, err := s.ChannelStore.GetChannelsByIds(channelIds, includeDeleted)
   990  
   991  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
   992  	if s.Root.Metrics != nil {
   993  		success := "false"
   994  		if err == nil {
   995  			success = "true"
   996  		}
   997  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelsByIds", success, elapsed)
   998  	}
   999  	return result, err
  1000  }
  1001  
  1002  func (s *TimerLayerChannelStore) GetChannelsByScheme(schemeId string, offset int, limit int) (model.ChannelList, error) {
  1003  	start := timemodule.Now()
  1004  
  1005  	result, err := s.ChannelStore.GetChannelsByScheme(schemeId, offset, limit)
  1006  
  1007  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1008  	if s.Root.Metrics != nil {
  1009  		success := "false"
  1010  		if err == nil {
  1011  			success = "true"
  1012  		}
  1013  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetChannelsByScheme", success, elapsed)
  1014  	}
  1015  	return result, err
  1016  }
  1017  
  1018  func (s *TimerLayerChannelStore) GetDeleted(team_id string, offset int, limit int, userId string) (*model.ChannelList, error) {
  1019  	start := timemodule.Now()
  1020  
  1021  	result, err := s.ChannelStore.GetDeleted(team_id, offset, limit, userId)
  1022  
  1023  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1024  	if s.Root.Metrics != nil {
  1025  		success := "false"
  1026  		if err == nil {
  1027  			success = "true"
  1028  		}
  1029  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetDeleted", success, elapsed)
  1030  	}
  1031  	return result, err
  1032  }
  1033  
  1034  func (s *TimerLayerChannelStore) GetDeletedByName(team_id string, name string) (*model.Channel, error) {
  1035  	start := timemodule.Now()
  1036  
  1037  	result, err := s.ChannelStore.GetDeletedByName(team_id, name)
  1038  
  1039  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1040  	if s.Root.Metrics != nil {
  1041  		success := "false"
  1042  		if err == nil {
  1043  			success = "true"
  1044  		}
  1045  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetDeletedByName", success, elapsed)
  1046  	}
  1047  	return result, err
  1048  }
  1049  
  1050  func (s *TimerLayerChannelStore) GetForPost(postId string) (*model.Channel, error) {
  1051  	start := timemodule.Now()
  1052  
  1053  	result, err := s.ChannelStore.GetForPost(postId)
  1054  
  1055  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1056  	if s.Root.Metrics != nil {
  1057  		success := "false"
  1058  		if err == nil {
  1059  			success = "true"
  1060  		}
  1061  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetForPost", success, elapsed)
  1062  	}
  1063  	return result, err
  1064  }
  1065  
  1066  func (s *TimerLayerChannelStore) GetFromMaster(id string) (*model.Channel, error) {
  1067  	start := timemodule.Now()
  1068  
  1069  	result, err := s.ChannelStore.GetFromMaster(id)
  1070  
  1071  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1072  	if s.Root.Metrics != nil {
  1073  		success := "false"
  1074  		if err == nil {
  1075  			success = "true"
  1076  		}
  1077  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetFromMaster", success, elapsed)
  1078  	}
  1079  	return result, err
  1080  }
  1081  
  1082  func (s *TimerLayerChannelStore) GetGuestCount(channelId string, allowFromCache bool) (int64, error) {
  1083  	start := timemodule.Now()
  1084  
  1085  	result, err := s.ChannelStore.GetGuestCount(channelId, allowFromCache)
  1086  
  1087  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1088  	if s.Root.Metrics != nil {
  1089  		success := "false"
  1090  		if err == nil {
  1091  			success = "true"
  1092  		}
  1093  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetGuestCount", success, elapsed)
  1094  	}
  1095  	return result, err
  1096  }
  1097  
  1098  func (s *TimerLayerChannelStore) GetMember(channelId string, userId string) (*model.ChannelMember, error) {
  1099  	start := timemodule.Now()
  1100  
  1101  	result, err := s.ChannelStore.GetMember(channelId, userId)
  1102  
  1103  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1104  	if s.Root.Metrics != nil {
  1105  		success := "false"
  1106  		if err == nil {
  1107  			success = "true"
  1108  		}
  1109  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMember", success, elapsed)
  1110  	}
  1111  	return result, err
  1112  }
  1113  
  1114  func (s *TimerLayerChannelStore) GetMemberCount(channelId string, allowFromCache bool) (int64, error) {
  1115  	start := timemodule.Now()
  1116  
  1117  	result, err := s.ChannelStore.GetMemberCount(channelId, allowFromCache)
  1118  
  1119  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1120  	if s.Root.Metrics != nil {
  1121  		success := "false"
  1122  		if err == nil {
  1123  			success = "true"
  1124  		}
  1125  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMemberCount", success, elapsed)
  1126  	}
  1127  	return result, err
  1128  }
  1129  
  1130  func (s *TimerLayerChannelStore) GetMemberCountFromCache(channelId string) int64 {
  1131  	start := timemodule.Now()
  1132  
  1133  	result := s.ChannelStore.GetMemberCountFromCache(channelId)
  1134  
  1135  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1136  	if s.Root.Metrics != nil {
  1137  		success := "false"
  1138  		if true {
  1139  			success = "true"
  1140  		}
  1141  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMemberCountFromCache", success, elapsed)
  1142  	}
  1143  	return result
  1144  }
  1145  
  1146  func (s *TimerLayerChannelStore) GetMemberCountsByGroup(channelID string, includeTimezones bool) ([]*model.ChannelMemberCountByGroup, error) {
  1147  	start := timemodule.Now()
  1148  
  1149  	result, err := s.ChannelStore.GetMemberCountsByGroup(channelID, includeTimezones)
  1150  
  1151  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1152  	if s.Root.Metrics != nil {
  1153  		success := "false"
  1154  		if err == nil {
  1155  			success = "true"
  1156  		}
  1157  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMemberCountsByGroup", success, elapsed)
  1158  	}
  1159  	return result, err
  1160  }
  1161  
  1162  func (s *TimerLayerChannelStore) GetMemberForPost(postId string, userId string) (*model.ChannelMember, error) {
  1163  	start := timemodule.Now()
  1164  
  1165  	result, err := s.ChannelStore.GetMemberForPost(postId, userId)
  1166  
  1167  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1168  	if s.Root.Metrics != nil {
  1169  		success := "false"
  1170  		if err == nil {
  1171  			success = "true"
  1172  		}
  1173  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMemberForPost", success, elapsed)
  1174  	}
  1175  	return result, err
  1176  }
  1177  
  1178  func (s *TimerLayerChannelStore) GetMembers(channelId string, offset int, limit int) (*model.ChannelMembers, error) {
  1179  	start := timemodule.Now()
  1180  
  1181  	result, err := s.ChannelStore.GetMembers(channelId, offset, limit)
  1182  
  1183  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1184  	if s.Root.Metrics != nil {
  1185  		success := "false"
  1186  		if err == nil {
  1187  			success = "true"
  1188  		}
  1189  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMembers", success, elapsed)
  1190  	}
  1191  	return result, err
  1192  }
  1193  
  1194  func (s *TimerLayerChannelStore) GetMembersByChannelIds(channelIds []string, userId string) (*model.ChannelMembers, error) {
  1195  	start := timemodule.Now()
  1196  
  1197  	result, err := s.ChannelStore.GetMembersByChannelIds(channelIds, userId)
  1198  
  1199  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1200  	if s.Root.Metrics != nil {
  1201  		success := "false"
  1202  		if err == nil {
  1203  			success = "true"
  1204  		}
  1205  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMembersByChannelIds", success, elapsed)
  1206  	}
  1207  	return result, err
  1208  }
  1209  
  1210  func (s *TimerLayerChannelStore) GetMembersByIds(channelId string, userIds []string) (*model.ChannelMembers, error) {
  1211  	start := timemodule.Now()
  1212  
  1213  	result, err := s.ChannelStore.GetMembersByIds(channelId, userIds)
  1214  
  1215  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1216  	if s.Root.Metrics != nil {
  1217  		success := "false"
  1218  		if err == nil {
  1219  			success = "true"
  1220  		}
  1221  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMembersByIds", success, elapsed)
  1222  	}
  1223  	return result, err
  1224  }
  1225  
  1226  func (s *TimerLayerChannelStore) GetMembersForUser(teamId string, userId string) (*model.ChannelMembers, error) {
  1227  	start := timemodule.Now()
  1228  
  1229  	result, err := s.ChannelStore.GetMembersForUser(teamId, userId)
  1230  
  1231  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1232  	if s.Root.Metrics != nil {
  1233  		success := "false"
  1234  		if err == nil {
  1235  			success = "true"
  1236  		}
  1237  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMembersForUser", success, elapsed)
  1238  	}
  1239  	return result, err
  1240  }
  1241  
  1242  func (s *TimerLayerChannelStore) GetMembersForUserWithPagination(teamId string, userId string, page int, perPage int) (*model.ChannelMembers, error) {
  1243  	start := timemodule.Now()
  1244  
  1245  	result, err := s.ChannelStore.GetMembersForUserWithPagination(teamId, userId, page, perPage)
  1246  
  1247  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1248  	if s.Root.Metrics != nil {
  1249  		success := "false"
  1250  		if err == nil {
  1251  			success = "true"
  1252  		}
  1253  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMembersForUserWithPagination", success, elapsed)
  1254  	}
  1255  	return result, err
  1256  }
  1257  
  1258  func (s *TimerLayerChannelStore) GetMoreChannels(teamId string, userId string, offset int, limit int) (*model.ChannelList, error) {
  1259  	start := timemodule.Now()
  1260  
  1261  	result, err := s.ChannelStore.GetMoreChannels(teamId, userId, offset, limit)
  1262  
  1263  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1264  	if s.Root.Metrics != nil {
  1265  		success := "false"
  1266  		if err == nil {
  1267  			success = "true"
  1268  		}
  1269  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetMoreChannels", success, elapsed)
  1270  	}
  1271  	return result, err
  1272  }
  1273  
  1274  func (s *TimerLayerChannelStore) GetPinnedPostCount(channelId string, allowFromCache bool) (int64, error) {
  1275  	start := timemodule.Now()
  1276  
  1277  	result, err := s.ChannelStore.GetPinnedPostCount(channelId, allowFromCache)
  1278  
  1279  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1280  	if s.Root.Metrics != nil {
  1281  		success := "false"
  1282  		if err == nil {
  1283  			success = "true"
  1284  		}
  1285  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetPinnedPostCount", success, elapsed)
  1286  	}
  1287  	return result, err
  1288  }
  1289  
  1290  func (s *TimerLayerChannelStore) GetPinnedPosts(channelId string) (*model.PostList, error) {
  1291  	start := timemodule.Now()
  1292  
  1293  	result, err := s.ChannelStore.GetPinnedPosts(channelId)
  1294  
  1295  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1296  	if s.Root.Metrics != nil {
  1297  		success := "false"
  1298  		if err == nil {
  1299  			success = "true"
  1300  		}
  1301  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetPinnedPosts", success, elapsed)
  1302  	}
  1303  	return result, err
  1304  }
  1305  
  1306  func (s *TimerLayerChannelStore) GetPrivateChannelsForTeam(teamId string, offset int, limit int) (*model.ChannelList, error) {
  1307  	start := timemodule.Now()
  1308  
  1309  	result, err := s.ChannelStore.GetPrivateChannelsForTeam(teamId, offset, limit)
  1310  
  1311  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1312  	if s.Root.Metrics != nil {
  1313  		success := "false"
  1314  		if err == nil {
  1315  			success = "true"
  1316  		}
  1317  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetPrivateChannelsForTeam", success, elapsed)
  1318  	}
  1319  	return result, err
  1320  }
  1321  
  1322  func (s *TimerLayerChannelStore) GetPublicChannelsByIdsForTeam(teamId string, channelIds []string) (*model.ChannelList, error) {
  1323  	start := timemodule.Now()
  1324  
  1325  	result, err := s.ChannelStore.GetPublicChannelsByIdsForTeam(teamId, channelIds)
  1326  
  1327  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1328  	if s.Root.Metrics != nil {
  1329  		success := "false"
  1330  		if err == nil {
  1331  			success = "true"
  1332  		}
  1333  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetPublicChannelsByIdsForTeam", success, elapsed)
  1334  	}
  1335  	return result, err
  1336  }
  1337  
  1338  func (s *TimerLayerChannelStore) GetPublicChannelsForTeam(teamId string, offset int, limit int) (*model.ChannelList, error) {
  1339  	start := timemodule.Now()
  1340  
  1341  	result, err := s.ChannelStore.GetPublicChannelsForTeam(teamId, offset, limit)
  1342  
  1343  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1344  	if s.Root.Metrics != nil {
  1345  		success := "false"
  1346  		if err == nil {
  1347  			success = "true"
  1348  		}
  1349  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetPublicChannelsForTeam", success, elapsed)
  1350  	}
  1351  	return result, err
  1352  }
  1353  
  1354  func (s *TimerLayerChannelStore) GetSidebarCategories(userId string, teamId string) (*model.OrderedSidebarCategories, error) {
  1355  	start := timemodule.Now()
  1356  
  1357  	result, err := s.ChannelStore.GetSidebarCategories(userId, teamId)
  1358  
  1359  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1360  	if s.Root.Metrics != nil {
  1361  		success := "false"
  1362  		if err == nil {
  1363  			success = "true"
  1364  		}
  1365  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetSidebarCategories", success, elapsed)
  1366  	}
  1367  	return result, err
  1368  }
  1369  
  1370  func (s *TimerLayerChannelStore) GetSidebarCategory(categoryId string) (*model.SidebarCategoryWithChannels, error) {
  1371  	start := timemodule.Now()
  1372  
  1373  	result, err := s.ChannelStore.GetSidebarCategory(categoryId)
  1374  
  1375  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1376  	if s.Root.Metrics != nil {
  1377  		success := "false"
  1378  		if err == nil {
  1379  			success = "true"
  1380  		}
  1381  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetSidebarCategory", success, elapsed)
  1382  	}
  1383  	return result, err
  1384  }
  1385  
  1386  func (s *TimerLayerChannelStore) GetSidebarCategoryOrder(userId string, teamId string) ([]string, error) {
  1387  	start := timemodule.Now()
  1388  
  1389  	result, err := s.ChannelStore.GetSidebarCategoryOrder(userId, teamId)
  1390  
  1391  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1392  	if s.Root.Metrics != nil {
  1393  		success := "false"
  1394  		if err == nil {
  1395  			success = "true"
  1396  		}
  1397  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetSidebarCategoryOrder", success, elapsed)
  1398  	}
  1399  	return result, err
  1400  }
  1401  
  1402  func (s *TimerLayerChannelStore) GetTeamChannels(teamId string) (*model.ChannelList, error) {
  1403  	start := timemodule.Now()
  1404  
  1405  	result, err := s.ChannelStore.GetTeamChannels(teamId)
  1406  
  1407  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1408  	if s.Root.Metrics != nil {
  1409  		success := "false"
  1410  		if err == nil {
  1411  			success = "true"
  1412  		}
  1413  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GetTeamChannels", success, elapsed)
  1414  	}
  1415  	return result, err
  1416  }
  1417  
  1418  func (s *TimerLayerChannelStore) GroupSyncedChannelCount() (int64, error) {
  1419  	start := timemodule.Now()
  1420  
  1421  	result, err := s.ChannelStore.GroupSyncedChannelCount()
  1422  
  1423  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1424  	if s.Root.Metrics != nil {
  1425  		success := "false"
  1426  		if err == nil {
  1427  			success = "true"
  1428  		}
  1429  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.GroupSyncedChannelCount", success, elapsed)
  1430  	}
  1431  	return result, err
  1432  }
  1433  
  1434  func (s *TimerLayerChannelStore) IncrementMentionCount(channelId string, userId string, updateThreads bool) error {
  1435  	start := timemodule.Now()
  1436  
  1437  	err := s.ChannelStore.IncrementMentionCount(channelId, userId, updateThreads)
  1438  
  1439  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1440  	if s.Root.Metrics != nil {
  1441  		success := "false"
  1442  		if err == nil {
  1443  			success = "true"
  1444  		}
  1445  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.IncrementMentionCount", success, elapsed)
  1446  	}
  1447  	return err
  1448  }
  1449  
  1450  func (s *TimerLayerChannelStore) InvalidateAllChannelMembersForUser(userId string) {
  1451  	start := timemodule.Now()
  1452  
  1453  	s.ChannelStore.InvalidateAllChannelMembersForUser(userId)
  1454  
  1455  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1456  	if s.Root.Metrics != nil {
  1457  		success := "false"
  1458  		if true {
  1459  			success = "true"
  1460  		}
  1461  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidateAllChannelMembersForUser", success, elapsed)
  1462  	}
  1463  }
  1464  
  1465  func (s *TimerLayerChannelStore) InvalidateCacheForChannelMembersNotifyProps(channelId string) {
  1466  	start := timemodule.Now()
  1467  
  1468  	s.ChannelStore.InvalidateCacheForChannelMembersNotifyProps(channelId)
  1469  
  1470  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1471  	if s.Root.Metrics != nil {
  1472  		success := "false"
  1473  		if true {
  1474  			success = "true"
  1475  		}
  1476  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidateCacheForChannelMembersNotifyProps", success, elapsed)
  1477  	}
  1478  }
  1479  
  1480  func (s *TimerLayerChannelStore) InvalidateChannel(id string) {
  1481  	start := timemodule.Now()
  1482  
  1483  	s.ChannelStore.InvalidateChannel(id)
  1484  
  1485  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1486  	if s.Root.Metrics != nil {
  1487  		success := "false"
  1488  		if true {
  1489  			success = "true"
  1490  		}
  1491  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidateChannel", success, elapsed)
  1492  	}
  1493  }
  1494  
  1495  func (s *TimerLayerChannelStore) InvalidateChannelByName(teamId string, name string) {
  1496  	start := timemodule.Now()
  1497  
  1498  	s.ChannelStore.InvalidateChannelByName(teamId, name)
  1499  
  1500  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1501  	if s.Root.Metrics != nil {
  1502  		success := "false"
  1503  		if true {
  1504  			success = "true"
  1505  		}
  1506  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidateChannelByName", success, elapsed)
  1507  	}
  1508  }
  1509  
  1510  func (s *TimerLayerChannelStore) InvalidateGuestCount(channelId string) {
  1511  	start := timemodule.Now()
  1512  
  1513  	s.ChannelStore.InvalidateGuestCount(channelId)
  1514  
  1515  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1516  	if s.Root.Metrics != nil {
  1517  		success := "false"
  1518  		if true {
  1519  			success = "true"
  1520  		}
  1521  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidateGuestCount", success, elapsed)
  1522  	}
  1523  }
  1524  
  1525  func (s *TimerLayerChannelStore) InvalidateMemberCount(channelId string) {
  1526  	start := timemodule.Now()
  1527  
  1528  	s.ChannelStore.InvalidateMemberCount(channelId)
  1529  
  1530  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1531  	if s.Root.Metrics != nil {
  1532  		success := "false"
  1533  		if true {
  1534  			success = "true"
  1535  		}
  1536  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidateMemberCount", success, elapsed)
  1537  	}
  1538  }
  1539  
  1540  func (s *TimerLayerChannelStore) InvalidatePinnedPostCount(channelId string) {
  1541  	start := timemodule.Now()
  1542  
  1543  	s.ChannelStore.InvalidatePinnedPostCount(channelId)
  1544  
  1545  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1546  	if s.Root.Metrics != nil {
  1547  		success := "false"
  1548  		if true {
  1549  			success = "true"
  1550  		}
  1551  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.InvalidatePinnedPostCount", success, elapsed)
  1552  	}
  1553  }
  1554  
  1555  func (s *TimerLayerChannelStore) IsUserInChannelUseCache(userId string, channelId string) bool {
  1556  	start := timemodule.Now()
  1557  
  1558  	result := s.ChannelStore.IsUserInChannelUseCache(userId, channelId)
  1559  
  1560  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1561  	if s.Root.Metrics != nil {
  1562  		success := "false"
  1563  		if true {
  1564  			success = "true"
  1565  		}
  1566  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.IsUserInChannelUseCache", success, elapsed)
  1567  	}
  1568  	return result
  1569  }
  1570  
  1571  func (s *TimerLayerChannelStore) MigrateChannelMembers(fromChannelId string, fromUserId string) (map[string]string, error) {
  1572  	start := timemodule.Now()
  1573  
  1574  	result, err := s.ChannelStore.MigrateChannelMembers(fromChannelId, fromUserId)
  1575  
  1576  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1577  	if s.Root.Metrics != nil {
  1578  		success := "false"
  1579  		if err == nil {
  1580  			success = "true"
  1581  		}
  1582  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.MigrateChannelMembers", success, elapsed)
  1583  	}
  1584  	return result, err
  1585  }
  1586  
  1587  func (s *TimerLayerChannelStore) MigratePublicChannels() error {
  1588  	start := timemodule.Now()
  1589  
  1590  	err := s.ChannelStore.MigratePublicChannels()
  1591  
  1592  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1593  	if s.Root.Metrics != nil {
  1594  		success := "false"
  1595  		if err == nil {
  1596  			success = "true"
  1597  		}
  1598  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.MigratePublicChannels", success, elapsed)
  1599  	}
  1600  	return err
  1601  }
  1602  
  1603  func (s *TimerLayerChannelStore) PermanentDelete(channelId string) error {
  1604  	start := timemodule.Now()
  1605  
  1606  	err := s.ChannelStore.PermanentDelete(channelId)
  1607  
  1608  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1609  	if s.Root.Metrics != nil {
  1610  		success := "false"
  1611  		if err == nil {
  1612  			success = "true"
  1613  		}
  1614  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.PermanentDelete", success, elapsed)
  1615  	}
  1616  	return err
  1617  }
  1618  
  1619  func (s *TimerLayerChannelStore) PermanentDeleteByTeam(teamId string) error {
  1620  	start := timemodule.Now()
  1621  
  1622  	err := s.ChannelStore.PermanentDeleteByTeam(teamId)
  1623  
  1624  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1625  	if s.Root.Metrics != nil {
  1626  		success := "false"
  1627  		if err == nil {
  1628  			success = "true"
  1629  		}
  1630  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.PermanentDeleteByTeam", success, elapsed)
  1631  	}
  1632  	return err
  1633  }
  1634  
  1635  func (s *TimerLayerChannelStore) PermanentDeleteMembersByChannel(channelId string) error {
  1636  	start := timemodule.Now()
  1637  
  1638  	err := s.ChannelStore.PermanentDeleteMembersByChannel(channelId)
  1639  
  1640  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1641  	if s.Root.Metrics != nil {
  1642  		success := "false"
  1643  		if err == nil {
  1644  			success = "true"
  1645  		}
  1646  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.PermanentDeleteMembersByChannel", success, elapsed)
  1647  	}
  1648  	return err
  1649  }
  1650  
  1651  func (s *TimerLayerChannelStore) PermanentDeleteMembersByUser(userId string) error {
  1652  	start := timemodule.Now()
  1653  
  1654  	err := s.ChannelStore.PermanentDeleteMembersByUser(userId)
  1655  
  1656  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1657  	if s.Root.Metrics != nil {
  1658  		success := "false"
  1659  		if err == nil {
  1660  			success = "true"
  1661  		}
  1662  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.PermanentDeleteMembersByUser", success, elapsed)
  1663  	}
  1664  	return err
  1665  }
  1666  
  1667  func (s *TimerLayerChannelStore) RemoveAllDeactivatedMembers(channelId string) error {
  1668  	start := timemodule.Now()
  1669  
  1670  	err := s.ChannelStore.RemoveAllDeactivatedMembers(channelId)
  1671  
  1672  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1673  	if s.Root.Metrics != nil {
  1674  		success := "false"
  1675  		if err == nil {
  1676  			success = "true"
  1677  		}
  1678  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.RemoveAllDeactivatedMembers", success, elapsed)
  1679  	}
  1680  	return err
  1681  }
  1682  
  1683  func (s *TimerLayerChannelStore) RemoveMember(channelId string, userId string) error {
  1684  	start := timemodule.Now()
  1685  
  1686  	err := s.ChannelStore.RemoveMember(channelId, userId)
  1687  
  1688  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1689  	if s.Root.Metrics != nil {
  1690  		success := "false"
  1691  		if err == nil {
  1692  			success = "true"
  1693  		}
  1694  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.RemoveMember", success, elapsed)
  1695  	}
  1696  	return err
  1697  }
  1698  
  1699  func (s *TimerLayerChannelStore) RemoveMembers(channelId string, userIds []string) error {
  1700  	start := timemodule.Now()
  1701  
  1702  	err := s.ChannelStore.RemoveMembers(channelId, userIds)
  1703  
  1704  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1705  	if s.Root.Metrics != nil {
  1706  		success := "false"
  1707  		if err == nil {
  1708  			success = "true"
  1709  		}
  1710  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.RemoveMembers", success, elapsed)
  1711  	}
  1712  	return err
  1713  }
  1714  
  1715  func (s *TimerLayerChannelStore) ResetAllChannelSchemes() error {
  1716  	start := timemodule.Now()
  1717  
  1718  	err := s.ChannelStore.ResetAllChannelSchemes()
  1719  
  1720  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1721  	if s.Root.Metrics != nil {
  1722  		success := "false"
  1723  		if err == nil {
  1724  			success = "true"
  1725  		}
  1726  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.ResetAllChannelSchemes", success, elapsed)
  1727  	}
  1728  	return err
  1729  }
  1730  
  1731  func (s *TimerLayerChannelStore) Restore(channelId string, time int64) error {
  1732  	start := timemodule.Now()
  1733  
  1734  	err := s.ChannelStore.Restore(channelId, time)
  1735  
  1736  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1737  	if s.Root.Metrics != nil {
  1738  		success := "false"
  1739  		if err == nil {
  1740  			success = "true"
  1741  		}
  1742  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.Restore", success, elapsed)
  1743  	}
  1744  	return err
  1745  }
  1746  
  1747  func (s *TimerLayerChannelStore) Save(channel *model.Channel, maxChannelsPerTeam int64) (*model.Channel, error) {
  1748  	start := timemodule.Now()
  1749  
  1750  	result, err := s.ChannelStore.Save(channel, maxChannelsPerTeam)
  1751  
  1752  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1753  	if s.Root.Metrics != nil {
  1754  		success := "false"
  1755  		if err == nil {
  1756  			success = "true"
  1757  		}
  1758  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.Save", success, elapsed)
  1759  	}
  1760  	return result, err
  1761  }
  1762  
  1763  func (s *TimerLayerChannelStore) SaveDirectChannel(channel *model.Channel, member1 *model.ChannelMember, member2 *model.ChannelMember) (*model.Channel, error) {
  1764  	start := timemodule.Now()
  1765  
  1766  	result, err := s.ChannelStore.SaveDirectChannel(channel, member1, member2)
  1767  
  1768  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1769  	if s.Root.Metrics != nil {
  1770  		success := "false"
  1771  		if err == nil {
  1772  			success = "true"
  1773  		}
  1774  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SaveDirectChannel", success, elapsed)
  1775  	}
  1776  	return result, err
  1777  }
  1778  
  1779  func (s *TimerLayerChannelStore) SaveMember(member *model.ChannelMember) (*model.ChannelMember, error) {
  1780  	start := timemodule.Now()
  1781  
  1782  	result, err := s.ChannelStore.SaveMember(member)
  1783  
  1784  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1785  	if s.Root.Metrics != nil {
  1786  		success := "false"
  1787  		if err == nil {
  1788  			success = "true"
  1789  		}
  1790  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SaveMember", success, elapsed)
  1791  	}
  1792  	return result, err
  1793  }
  1794  
  1795  func (s *TimerLayerChannelStore) SaveMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
  1796  	start := timemodule.Now()
  1797  
  1798  	result, err := s.ChannelStore.SaveMultipleMembers(members)
  1799  
  1800  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1801  	if s.Root.Metrics != nil {
  1802  		success := "false"
  1803  		if err == nil {
  1804  			success = "true"
  1805  		}
  1806  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SaveMultipleMembers", success, elapsed)
  1807  	}
  1808  	return result, err
  1809  }
  1810  
  1811  func (s *TimerLayerChannelStore) SearchAllChannels(term string, opts store.ChannelSearchOpts) (*model.ChannelListWithTeamData, int64, error) {
  1812  	start := timemodule.Now()
  1813  
  1814  	result, resultVar1, err := s.ChannelStore.SearchAllChannels(term, opts)
  1815  
  1816  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1817  	if s.Root.Metrics != nil {
  1818  		success := "false"
  1819  		if err == nil {
  1820  			success = "true"
  1821  		}
  1822  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SearchAllChannels", success, elapsed)
  1823  	}
  1824  	return result, resultVar1, err
  1825  }
  1826  
  1827  func (s *TimerLayerChannelStore) SearchArchivedInTeam(teamId string, term string, userId string) (*model.ChannelList, error) {
  1828  	start := timemodule.Now()
  1829  
  1830  	result, err := s.ChannelStore.SearchArchivedInTeam(teamId, term, userId)
  1831  
  1832  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1833  	if s.Root.Metrics != nil {
  1834  		success := "false"
  1835  		if err == nil {
  1836  			success = "true"
  1837  		}
  1838  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SearchArchivedInTeam", success, elapsed)
  1839  	}
  1840  	return result, err
  1841  }
  1842  
  1843  func (s *TimerLayerChannelStore) SearchForUserInTeam(userId string, teamId string, term string, includeDeleted bool) (*model.ChannelList, error) {
  1844  	start := timemodule.Now()
  1845  
  1846  	result, err := s.ChannelStore.SearchForUserInTeam(userId, teamId, term, includeDeleted)
  1847  
  1848  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1849  	if s.Root.Metrics != nil {
  1850  		success := "false"
  1851  		if err == nil {
  1852  			success = "true"
  1853  		}
  1854  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SearchForUserInTeam", success, elapsed)
  1855  	}
  1856  	return result, err
  1857  }
  1858  
  1859  func (s *TimerLayerChannelStore) SearchGroupChannels(userId string, term string) (*model.ChannelList, error) {
  1860  	start := timemodule.Now()
  1861  
  1862  	result, err := s.ChannelStore.SearchGroupChannels(userId, term)
  1863  
  1864  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1865  	if s.Root.Metrics != nil {
  1866  		success := "false"
  1867  		if err == nil {
  1868  			success = "true"
  1869  		}
  1870  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SearchGroupChannels", success, elapsed)
  1871  	}
  1872  	return result, err
  1873  }
  1874  
  1875  func (s *TimerLayerChannelStore) SearchInTeam(teamId string, term string, includeDeleted bool) (*model.ChannelList, error) {
  1876  	start := timemodule.Now()
  1877  
  1878  	result, err := s.ChannelStore.SearchInTeam(teamId, term, includeDeleted)
  1879  
  1880  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1881  	if s.Root.Metrics != nil {
  1882  		success := "false"
  1883  		if err == nil {
  1884  			success = "true"
  1885  		}
  1886  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SearchInTeam", success, elapsed)
  1887  	}
  1888  	return result, err
  1889  }
  1890  
  1891  func (s *TimerLayerChannelStore) SearchMore(userId string, teamId string, term string) (*model.ChannelList, error) {
  1892  	start := timemodule.Now()
  1893  
  1894  	result, err := s.ChannelStore.SearchMore(userId, teamId, term)
  1895  
  1896  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1897  	if s.Root.Metrics != nil {
  1898  		success := "false"
  1899  		if err == nil {
  1900  			success = "true"
  1901  		}
  1902  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SearchMore", success, elapsed)
  1903  	}
  1904  	return result, err
  1905  }
  1906  
  1907  func (s *TimerLayerChannelStore) SetDeleteAt(channelId string, deleteAt int64, updateAt int64) error {
  1908  	start := timemodule.Now()
  1909  
  1910  	err := s.ChannelStore.SetDeleteAt(channelId, deleteAt, updateAt)
  1911  
  1912  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1913  	if s.Root.Metrics != nil {
  1914  		success := "false"
  1915  		if err == nil {
  1916  			success = "true"
  1917  		}
  1918  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.SetDeleteAt", success, elapsed)
  1919  	}
  1920  	return err
  1921  }
  1922  
  1923  func (s *TimerLayerChannelStore) Update(channel *model.Channel) (*model.Channel, error) {
  1924  	start := timemodule.Now()
  1925  
  1926  	result, err := s.ChannelStore.Update(channel)
  1927  
  1928  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1929  	if s.Root.Metrics != nil {
  1930  		success := "false"
  1931  		if err == nil {
  1932  			success = "true"
  1933  		}
  1934  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.Update", success, elapsed)
  1935  	}
  1936  	return result, err
  1937  }
  1938  
  1939  func (s *TimerLayerChannelStore) UpdateLastViewedAt(channelIds []string, userId string, updateThreads bool) (map[string]int64, error) {
  1940  	start := timemodule.Now()
  1941  
  1942  	result, err := s.ChannelStore.UpdateLastViewedAt(channelIds, userId, updateThreads)
  1943  
  1944  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1945  	if s.Root.Metrics != nil {
  1946  		success := "false"
  1947  		if err == nil {
  1948  			success = "true"
  1949  		}
  1950  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateLastViewedAt", success, elapsed)
  1951  	}
  1952  	return result, err
  1953  }
  1954  
  1955  func (s *TimerLayerChannelStore) UpdateLastViewedAtPost(unreadPost *model.Post, userID string, mentionCount int, updateThreads bool) (*model.ChannelUnreadAt, error) {
  1956  	start := timemodule.Now()
  1957  
  1958  	result, err := s.ChannelStore.UpdateLastViewedAtPost(unreadPost, userID, mentionCount, updateThreads)
  1959  
  1960  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1961  	if s.Root.Metrics != nil {
  1962  		success := "false"
  1963  		if err == nil {
  1964  			success = "true"
  1965  		}
  1966  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateLastViewedAtPost", success, elapsed)
  1967  	}
  1968  	return result, err
  1969  }
  1970  
  1971  func (s *TimerLayerChannelStore) UpdateMember(member *model.ChannelMember) (*model.ChannelMember, error) {
  1972  	start := timemodule.Now()
  1973  
  1974  	result, err := s.ChannelStore.UpdateMember(member)
  1975  
  1976  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1977  	if s.Root.Metrics != nil {
  1978  		success := "false"
  1979  		if err == nil {
  1980  			success = "true"
  1981  		}
  1982  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateMember", success, elapsed)
  1983  	}
  1984  	return result, err
  1985  }
  1986  
  1987  func (s *TimerLayerChannelStore) UpdateMembersRole(channelID string, userIDs []string) error {
  1988  	start := timemodule.Now()
  1989  
  1990  	err := s.ChannelStore.UpdateMembersRole(channelID, userIDs)
  1991  
  1992  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  1993  	if s.Root.Metrics != nil {
  1994  		success := "false"
  1995  		if err == nil {
  1996  			success = "true"
  1997  		}
  1998  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateMembersRole", success, elapsed)
  1999  	}
  2000  	return err
  2001  }
  2002  
  2003  func (s *TimerLayerChannelStore) UpdateMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
  2004  	start := timemodule.Now()
  2005  
  2006  	result, err := s.ChannelStore.UpdateMultipleMembers(members)
  2007  
  2008  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2009  	if s.Root.Metrics != nil {
  2010  		success := "false"
  2011  		if err == nil {
  2012  			success = "true"
  2013  		}
  2014  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateMultipleMembers", success, elapsed)
  2015  	}
  2016  	return result, err
  2017  }
  2018  
  2019  func (s *TimerLayerChannelStore) UpdateSidebarCategories(userId string, teamId string, categories []*model.SidebarCategoryWithChannels) ([]*model.SidebarCategoryWithChannels, []*model.SidebarCategoryWithChannels, error) {
  2020  	start := timemodule.Now()
  2021  
  2022  	result, resultVar1, err := s.ChannelStore.UpdateSidebarCategories(userId, teamId, categories)
  2023  
  2024  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2025  	if s.Root.Metrics != nil {
  2026  		success := "false"
  2027  		if err == nil {
  2028  			success = "true"
  2029  		}
  2030  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateSidebarCategories", success, elapsed)
  2031  	}
  2032  	return result, resultVar1, err
  2033  }
  2034  
  2035  func (s *TimerLayerChannelStore) UpdateSidebarCategoryOrder(userId string, teamId string, categoryOrder []string) error {
  2036  	start := timemodule.Now()
  2037  
  2038  	err := s.ChannelStore.UpdateSidebarCategoryOrder(userId, teamId, categoryOrder)
  2039  
  2040  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2041  	if s.Root.Metrics != nil {
  2042  		success := "false"
  2043  		if err == nil {
  2044  			success = "true"
  2045  		}
  2046  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateSidebarCategoryOrder", success, elapsed)
  2047  	}
  2048  	return err
  2049  }
  2050  
  2051  func (s *TimerLayerChannelStore) UpdateSidebarChannelCategoryOnMove(channel *model.Channel, newTeamId string) error {
  2052  	start := timemodule.Now()
  2053  
  2054  	err := s.ChannelStore.UpdateSidebarChannelCategoryOnMove(channel, newTeamId)
  2055  
  2056  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2057  	if s.Root.Metrics != nil {
  2058  		success := "false"
  2059  		if err == nil {
  2060  			success = "true"
  2061  		}
  2062  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateSidebarChannelCategoryOnMove", success, elapsed)
  2063  	}
  2064  	return err
  2065  }
  2066  
  2067  func (s *TimerLayerChannelStore) UpdateSidebarChannelsByPreferences(preferences *model.Preferences) error {
  2068  	start := timemodule.Now()
  2069  
  2070  	err := s.ChannelStore.UpdateSidebarChannelsByPreferences(preferences)
  2071  
  2072  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2073  	if s.Root.Metrics != nil {
  2074  		success := "false"
  2075  		if err == nil {
  2076  			success = "true"
  2077  		}
  2078  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UpdateSidebarChannelsByPreferences", success, elapsed)
  2079  	}
  2080  	return err
  2081  }
  2082  
  2083  func (s *TimerLayerChannelStore) UserBelongsToChannels(userId string, channelIds []string) (bool, error) {
  2084  	start := timemodule.Now()
  2085  
  2086  	result, err := s.ChannelStore.UserBelongsToChannels(userId, channelIds)
  2087  
  2088  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2089  	if s.Root.Metrics != nil {
  2090  		success := "false"
  2091  		if err == nil {
  2092  			success = "true"
  2093  		}
  2094  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelStore.UserBelongsToChannels", success, elapsed)
  2095  	}
  2096  	return result, err
  2097  }
  2098  
  2099  func (s *TimerLayerChannelMemberHistoryStore) GetUsersInChannelDuring(startTime int64, endTime int64, channelId string) ([]*model.ChannelMemberHistoryResult, error) {
  2100  	start := timemodule.Now()
  2101  
  2102  	result, err := s.ChannelMemberHistoryStore.GetUsersInChannelDuring(startTime, endTime, channelId)
  2103  
  2104  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2105  	if s.Root.Metrics != nil {
  2106  		success := "false"
  2107  		if err == nil {
  2108  			success = "true"
  2109  		}
  2110  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelMemberHistoryStore.GetUsersInChannelDuring", success, elapsed)
  2111  	}
  2112  	return result, err
  2113  }
  2114  
  2115  func (s *TimerLayerChannelMemberHistoryStore) LogJoinEvent(userId string, channelId string, joinTime int64) error {
  2116  	start := timemodule.Now()
  2117  
  2118  	err := s.ChannelMemberHistoryStore.LogJoinEvent(userId, channelId, joinTime)
  2119  
  2120  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2121  	if s.Root.Metrics != nil {
  2122  		success := "false"
  2123  		if err == nil {
  2124  			success = "true"
  2125  		}
  2126  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelMemberHistoryStore.LogJoinEvent", success, elapsed)
  2127  	}
  2128  	return err
  2129  }
  2130  
  2131  func (s *TimerLayerChannelMemberHistoryStore) LogLeaveEvent(userId string, channelId string, leaveTime int64) error {
  2132  	start := timemodule.Now()
  2133  
  2134  	err := s.ChannelMemberHistoryStore.LogLeaveEvent(userId, channelId, leaveTime)
  2135  
  2136  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2137  	if s.Root.Metrics != nil {
  2138  		success := "false"
  2139  		if err == nil {
  2140  			success = "true"
  2141  		}
  2142  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelMemberHistoryStore.LogLeaveEvent", success, elapsed)
  2143  	}
  2144  	return err
  2145  }
  2146  
  2147  func (s *TimerLayerChannelMemberHistoryStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, error) {
  2148  	start := timemodule.Now()
  2149  
  2150  	result, err := s.ChannelMemberHistoryStore.PermanentDeleteBatch(endTime, limit)
  2151  
  2152  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2153  	if s.Root.Metrics != nil {
  2154  		success := "false"
  2155  		if err == nil {
  2156  			success = "true"
  2157  		}
  2158  		s.Root.Metrics.ObserveStoreMethodDuration("ChannelMemberHistoryStore.PermanentDeleteBatch", success, elapsed)
  2159  	}
  2160  	return result, err
  2161  }
  2162  
  2163  func (s *TimerLayerClusterDiscoveryStore) Cleanup() error {
  2164  	start := timemodule.Now()
  2165  
  2166  	err := s.ClusterDiscoveryStore.Cleanup()
  2167  
  2168  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2169  	if s.Root.Metrics != nil {
  2170  		success := "false"
  2171  		if err == nil {
  2172  			success = "true"
  2173  		}
  2174  		s.Root.Metrics.ObserveStoreMethodDuration("ClusterDiscoveryStore.Cleanup", success, elapsed)
  2175  	}
  2176  	return err
  2177  }
  2178  
  2179  func (s *TimerLayerClusterDiscoveryStore) Delete(discovery *model.ClusterDiscovery) (bool, error) {
  2180  	start := timemodule.Now()
  2181  
  2182  	result, err := s.ClusterDiscoveryStore.Delete(discovery)
  2183  
  2184  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2185  	if s.Root.Metrics != nil {
  2186  		success := "false"
  2187  		if err == nil {
  2188  			success = "true"
  2189  		}
  2190  		s.Root.Metrics.ObserveStoreMethodDuration("ClusterDiscoveryStore.Delete", success, elapsed)
  2191  	}
  2192  	return result, err
  2193  }
  2194  
  2195  func (s *TimerLayerClusterDiscoveryStore) Exists(discovery *model.ClusterDiscovery) (bool, error) {
  2196  	start := timemodule.Now()
  2197  
  2198  	result, err := s.ClusterDiscoveryStore.Exists(discovery)
  2199  
  2200  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2201  	if s.Root.Metrics != nil {
  2202  		success := "false"
  2203  		if err == nil {
  2204  			success = "true"
  2205  		}
  2206  		s.Root.Metrics.ObserveStoreMethodDuration("ClusterDiscoveryStore.Exists", success, elapsed)
  2207  	}
  2208  	return result, err
  2209  }
  2210  
  2211  func (s *TimerLayerClusterDiscoveryStore) GetAll(discoveryType string, clusterName string) ([]*model.ClusterDiscovery, error) {
  2212  	start := timemodule.Now()
  2213  
  2214  	result, err := s.ClusterDiscoveryStore.GetAll(discoveryType, clusterName)
  2215  
  2216  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2217  	if s.Root.Metrics != nil {
  2218  		success := "false"
  2219  		if err == nil {
  2220  			success = "true"
  2221  		}
  2222  		s.Root.Metrics.ObserveStoreMethodDuration("ClusterDiscoveryStore.GetAll", success, elapsed)
  2223  	}
  2224  	return result, err
  2225  }
  2226  
  2227  func (s *TimerLayerClusterDiscoveryStore) Save(discovery *model.ClusterDiscovery) error {
  2228  	start := timemodule.Now()
  2229  
  2230  	err := s.ClusterDiscoveryStore.Save(discovery)
  2231  
  2232  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2233  	if s.Root.Metrics != nil {
  2234  		success := "false"
  2235  		if err == nil {
  2236  			success = "true"
  2237  		}
  2238  		s.Root.Metrics.ObserveStoreMethodDuration("ClusterDiscoveryStore.Save", success, elapsed)
  2239  	}
  2240  	return err
  2241  }
  2242  
  2243  func (s *TimerLayerClusterDiscoveryStore) SetLastPingAt(discovery *model.ClusterDiscovery) error {
  2244  	start := timemodule.Now()
  2245  
  2246  	err := s.ClusterDiscoveryStore.SetLastPingAt(discovery)
  2247  
  2248  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2249  	if s.Root.Metrics != nil {
  2250  		success := "false"
  2251  		if err == nil {
  2252  			success = "true"
  2253  		}
  2254  		s.Root.Metrics.ObserveStoreMethodDuration("ClusterDiscoveryStore.SetLastPingAt", success, elapsed)
  2255  	}
  2256  	return err
  2257  }
  2258  
  2259  func (s *TimerLayerCommandStore) AnalyticsCommandCount(teamId string) (int64, error) {
  2260  	start := timemodule.Now()
  2261  
  2262  	result, err := s.CommandStore.AnalyticsCommandCount(teamId)
  2263  
  2264  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2265  	if s.Root.Metrics != nil {
  2266  		success := "false"
  2267  		if err == nil {
  2268  			success = "true"
  2269  		}
  2270  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.AnalyticsCommandCount", success, elapsed)
  2271  	}
  2272  	return result, err
  2273  }
  2274  
  2275  func (s *TimerLayerCommandStore) Delete(commandId string, time int64) error {
  2276  	start := timemodule.Now()
  2277  
  2278  	err := s.CommandStore.Delete(commandId, time)
  2279  
  2280  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2281  	if s.Root.Metrics != nil {
  2282  		success := "false"
  2283  		if err == nil {
  2284  			success = "true"
  2285  		}
  2286  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.Delete", success, elapsed)
  2287  	}
  2288  	return err
  2289  }
  2290  
  2291  func (s *TimerLayerCommandStore) Get(id string) (*model.Command, error) {
  2292  	start := timemodule.Now()
  2293  
  2294  	result, err := s.CommandStore.Get(id)
  2295  
  2296  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2297  	if s.Root.Metrics != nil {
  2298  		success := "false"
  2299  		if err == nil {
  2300  			success = "true"
  2301  		}
  2302  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.Get", success, elapsed)
  2303  	}
  2304  	return result, err
  2305  }
  2306  
  2307  func (s *TimerLayerCommandStore) GetByTeam(teamId string) ([]*model.Command, error) {
  2308  	start := timemodule.Now()
  2309  
  2310  	result, err := s.CommandStore.GetByTeam(teamId)
  2311  
  2312  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2313  	if s.Root.Metrics != nil {
  2314  		success := "false"
  2315  		if err == nil {
  2316  			success = "true"
  2317  		}
  2318  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.GetByTeam", success, elapsed)
  2319  	}
  2320  	return result, err
  2321  }
  2322  
  2323  func (s *TimerLayerCommandStore) GetByTrigger(teamId string, trigger string) (*model.Command, error) {
  2324  	start := timemodule.Now()
  2325  
  2326  	result, err := s.CommandStore.GetByTrigger(teamId, trigger)
  2327  
  2328  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2329  	if s.Root.Metrics != nil {
  2330  		success := "false"
  2331  		if err == nil {
  2332  			success = "true"
  2333  		}
  2334  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.GetByTrigger", success, elapsed)
  2335  	}
  2336  	return result, err
  2337  }
  2338  
  2339  func (s *TimerLayerCommandStore) PermanentDeleteByTeam(teamId string) error {
  2340  	start := timemodule.Now()
  2341  
  2342  	err := s.CommandStore.PermanentDeleteByTeam(teamId)
  2343  
  2344  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2345  	if s.Root.Metrics != nil {
  2346  		success := "false"
  2347  		if err == nil {
  2348  			success = "true"
  2349  		}
  2350  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.PermanentDeleteByTeam", success, elapsed)
  2351  	}
  2352  	return err
  2353  }
  2354  
  2355  func (s *TimerLayerCommandStore) PermanentDeleteByUser(userId string) error {
  2356  	start := timemodule.Now()
  2357  
  2358  	err := s.CommandStore.PermanentDeleteByUser(userId)
  2359  
  2360  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2361  	if s.Root.Metrics != nil {
  2362  		success := "false"
  2363  		if err == nil {
  2364  			success = "true"
  2365  		}
  2366  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.PermanentDeleteByUser", success, elapsed)
  2367  	}
  2368  	return err
  2369  }
  2370  
  2371  func (s *TimerLayerCommandStore) Save(webhook *model.Command) (*model.Command, error) {
  2372  	start := timemodule.Now()
  2373  
  2374  	result, err := s.CommandStore.Save(webhook)
  2375  
  2376  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2377  	if s.Root.Metrics != nil {
  2378  		success := "false"
  2379  		if err == nil {
  2380  			success = "true"
  2381  		}
  2382  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.Save", success, elapsed)
  2383  	}
  2384  	return result, err
  2385  }
  2386  
  2387  func (s *TimerLayerCommandStore) Update(hook *model.Command) (*model.Command, error) {
  2388  	start := timemodule.Now()
  2389  
  2390  	result, err := s.CommandStore.Update(hook)
  2391  
  2392  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2393  	if s.Root.Metrics != nil {
  2394  		success := "false"
  2395  		if err == nil {
  2396  			success = "true"
  2397  		}
  2398  		s.Root.Metrics.ObserveStoreMethodDuration("CommandStore.Update", success, elapsed)
  2399  	}
  2400  	return result, err
  2401  }
  2402  
  2403  func (s *TimerLayerCommandWebhookStore) Cleanup() {
  2404  	start := timemodule.Now()
  2405  
  2406  	s.CommandWebhookStore.Cleanup()
  2407  
  2408  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2409  	if s.Root.Metrics != nil {
  2410  		success := "false"
  2411  		if true {
  2412  			success = "true"
  2413  		}
  2414  		s.Root.Metrics.ObserveStoreMethodDuration("CommandWebhookStore.Cleanup", success, elapsed)
  2415  	}
  2416  }
  2417  
  2418  func (s *TimerLayerCommandWebhookStore) Get(id string) (*model.CommandWebhook, error) {
  2419  	start := timemodule.Now()
  2420  
  2421  	result, err := s.CommandWebhookStore.Get(id)
  2422  
  2423  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2424  	if s.Root.Metrics != nil {
  2425  		success := "false"
  2426  		if err == nil {
  2427  			success = "true"
  2428  		}
  2429  		s.Root.Metrics.ObserveStoreMethodDuration("CommandWebhookStore.Get", success, elapsed)
  2430  	}
  2431  	return result, err
  2432  }
  2433  
  2434  func (s *TimerLayerCommandWebhookStore) Save(webhook *model.CommandWebhook) (*model.CommandWebhook, error) {
  2435  	start := timemodule.Now()
  2436  
  2437  	result, err := s.CommandWebhookStore.Save(webhook)
  2438  
  2439  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2440  	if s.Root.Metrics != nil {
  2441  		success := "false"
  2442  		if err == nil {
  2443  			success = "true"
  2444  		}
  2445  		s.Root.Metrics.ObserveStoreMethodDuration("CommandWebhookStore.Save", success, elapsed)
  2446  	}
  2447  	return result, err
  2448  }
  2449  
  2450  func (s *TimerLayerCommandWebhookStore) TryUse(id string, limit int) error {
  2451  	start := timemodule.Now()
  2452  
  2453  	err := s.CommandWebhookStore.TryUse(id, limit)
  2454  
  2455  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2456  	if s.Root.Metrics != nil {
  2457  		success := "false"
  2458  		if err == nil {
  2459  			success = "true"
  2460  		}
  2461  		s.Root.Metrics.ObserveStoreMethodDuration("CommandWebhookStore.TryUse", success, elapsed)
  2462  	}
  2463  	return err
  2464  }
  2465  
  2466  func (s *TimerLayerComplianceStore) ComplianceExport(compliance *model.Compliance) ([]*model.CompliancePost, error) {
  2467  	start := timemodule.Now()
  2468  
  2469  	result, err := s.ComplianceStore.ComplianceExport(compliance)
  2470  
  2471  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2472  	if s.Root.Metrics != nil {
  2473  		success := "false"
  2474  		if err == nil {
  2475  			success = "true"
  2476  		}
  2477  		s.Root.Metrics.ObserveStoreMethodDuration("ComplianceStore.ComplianceExport", success, elapsed)
  2478  	}
  2479  	return result, err
  2480  }
  2481  
  2482  func (s *TimerLayerComplianceStore) Get(id string) (*model.Compliance, error) {
  2483  	start := timemodule.Now()
  2484  
  2485  	result, err := s.ComplianceStore.Get(id)
  2486  
  2487  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2488  	if s.Root.Metrics != nil {
  2489  		success := "false"
  2490  		if err == nil {
  2491  			success = "true"
  2492  		}
  2493  		s.Root.Metrics.ObserveStoreMethodDuration("ComplianceStore.Get", success, elapsed)
  2494  	}
  2495  	return result, err
  2496  }
  2497  
  2498  func (s *TimerLayerComplianceStore) GetAll(offset int, limit int) (model.Compliances, error) {
  2499  	start := timemodule.Now()
  2500  
  2501  	result, err := s.ComplianceStore.GetAll(offset, limit)
  2502  
  2503  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2504  	if s.Root.Metrics != nil {
  2505  		success := "false"
  2506  		if err == nil {
  2507  			success = "true"
  2508  		}
  2509  		s.Root.Metrics.ObserveStoreMethodDuration("ComplianceStore.GetAll", success, elapsed)
  2510  	}
  2511  	return result, err
  2512  }
  2513  
  2514  func (s *TimerLayerComplianceStore) MessageExport(after int64, limit int) ([]*model.MessageExport, error) {
  2515  	start := timemodule.Now()
  2516  
  2517  	result, err := s.ComplianceStore.MessageExport(after, limit)
  2518  
  2519  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2520  	if s.Root.Metrics != nil {
  2521  		success := "false"
  2522  		if err == nil {
  2523  			success = "true"
  2524  		}
  2525  		s.Root.Metrics.ObserveStoreMethodDuration("ComplianceStore.MessageExport", success, elapsed)
  2526  	}
  2527  	return result, err
  2528  }
  2529  
  2530  func (s *TimerLayerComplianceStore) Save(compliance *model.Compliance) (*model.Compliance, error) {
  2531  	start := timemodule.Now()
  2532  
  2533  	result, err := s.ComplianceStore.Save(compliance)
  2534  
  2535  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2536  	if s.Root.Metrics != nil {
  2537  		success := "false"
  2538  		if err == nil {
  2539  			success = "true"
  2540  		}
  2541  		s.Root.Metrics.ObserveStoreMethodDuration("ComplianceStore.Save", success, elapsed)
  2542  	}
  2543  	return result, err
  2544  }
  2545  
  2546  func (s *TimerLayerComplianceStore) Update(compliance *model.Compliance) (*model.Compliance, error) {
  2547  	start := timemodule.Now()
  2548  
  2549  	result, err := s.ComplianceStore.Update(compliance)
  2550  
  2551  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2552  	if s.Root.Metrics != nil {
  2553  		success := "false"
  2554  		if err == nil {
  2555  			success = "true"
  2556  		}
  2557  		s.Root.Metrics.ObserveStoreMethodDuration("ComplianceStore.Update", success, elapsed)
  2558  	}
  2559  	return result, err
  2560  }
  2561  
  2562  func (s *TimerLayerEmojiStore) Delete(emoji *model.Emoji, time int64) error {
  2563  	start := timemodule.Now()
  2564  
  2565  	err := s.EmojiStore.Delete(emoji, time)
  2566  
  2567  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2568  	if s.Root.Metrics != nil {
  2569  		success := "false"
  2570  		if err == nil {
  2571  			success = "true"
  2572  		}
  2573  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.Delete", success, elapsed)
  2574  	}
  2575  	return err
  2576  }
  2577  
  2578  func (s *TimerLayerEmojiStore) Get(id string, allowFromCache bool) (*model.Emoji, error) {
  2579  	start := timemodule.Now()
  2580  
  2581  	result, err := s.EmojiStore.Get(id, allowFromCache)
  2582  
  2583  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2584  	if s.Root.Metrics != nil {
  2585  		success := "false"
  2586  		if err == nil {
  2587  			success = "true"
  2588  		}
  2589  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.Get", success, elapsed)
  2590  	}
  2591  	return result, err
  2592  }
  2593  
  2594  func (s *TimerLayerEmojiStore) GetByName(name string, allowFromCache bool) (*model.Emoji, error) {
  2595  	start := timemodule.Now()
  2596  
  2597  	result, err := s.EmojiStore.GetByName(name, allowFromCache)
  2598  
  2599  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2600  	if s.Root.Metrics != nil {
  2601  		success := "false"
  2602  		if err == nil {
  2603  			success = "true"
  2604  		}
  2605  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.GetByName", success, elapsed)
  2606  	}
  2607  	return result, err
  2608  }
  2609  
  2610  func (s *TimerLayerEmojiStore) GetList(offset int, limit int, sort string) ([]*model.Emoji, error) {
  2611  	start := timemodule.Now()
  2612  
  2613  	result, err := s.EmojiStore.GetList(offset, limit, sort)
  2614  
  2615  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2616  	if s.Root.Metrics != nil {
  2617  		success := "false"
  2618  		if err == nil {
  2619  			success = "true"
  2620  		}
  2621  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.GetList", success, elapsed)
  2622  	}
  2623  	return result, err
  2624  }
  2625  
  2626  func (s *TimerLayerEmojiStore) GetMultipleByName(names []string) ([]*model.Emoji, error) {
  2627  	start := timemodule.Now()
  2628  
  2629  	result, err := s.EmojiStore.GetMultipleByName(names)
  2630  
  2631  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2632  	if s.Root.Metrics != nil {
  2633  		success := "false"
  2634  		if err == nil {
  2635  			success = "true"
  2636  		}
  2637  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.GetMultipleByName", success, elapsed)
  2638  	}
  2639  	return result, err
  2640  }
  2641  
  2642  func (s *TimerLayerEmojiStore) Save(emoji *model.Emoji) (*model.Emoji, error) {
  2643  	start := timemodule.Now()
  2644  
  2645  	result, err := s.EmojiStore.Save(emoji)
  2646  
  2647  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2648  	if s.Root.Metrics != nil {
  2649  		success := "false"
  2650  		if err == nil {
  2651  			success = "true"
  2652  		}
  2653  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.Save", success, elapsed)
  2654  	}
  2655  	return result, err
  2656  }
  2657  
  2658  func (s *TimerLayerEmojiStore) Search(name string, prefixOnly bool, limit int) ([]*model.Emoji, error) {
  2659  	start := timemodule.Now()
  2660  
  2661  	result, err := s.EmojiStore.Search(name, prefixOnly, limit)
  2662  
  2663  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2664  	if s.Root.Metrics != nil {
  2665  		success := "false"
  2666  		if err == nil {
  2667  			success = "true"
  2668  		}
  2669  		s.Root.Metrics.ObserveStoreMethodDuration("EmojiStore.Search", success, elapsed)
  2670  	}
  2671  	return result, err
  2672  }
  2673  
  2674  func (s *TimerLayerFileInfoStore) AttachToPost(fileId string, postId string, creatorId string) error {
  2675  	start := timemodule.Now()
  2676  
  2677  	err := s.FileInfoStore.AttachToPost(fileId, postId, creatorId)
  2678  
  2679  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2680  	if s.Root.Metrics != nil {
  2681  		success := "false"
  2682  		if err == nil {
  2683  			success = "true"
  2684  		}
  2685  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.AttachToPost", success, elapsed)
  2686  	}
  2687  	return err
  2688  }
  2689  
  2690  func (s *TimerLayerFileInfoStore) ClearCaches() {
  2691  	start := timemodule.Now()
  2692  
  2693  	s.FileInfoStore.ClearCaches()
  2694  
  2695  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2696  	if s.Root.Metrics != nil {
  2697  		success := "false"
  2698  		if true {
  2699  			success = "true"
  2700  		}
  2701  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.ClearCaches", success, elapsed)
  2702  	}
  2703  }
  2704  
  2705  func (s *TimerLayerFileInfoStore) DeleteForPost(postId string) (string, error) {
  2706  	start := timemodule.Now()
  2707  
  2708  	result, err := s.FileInfoStore.DeleteForPost(postId)
  2709  
  2710  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2711  	if s.Root.Metrics != nil {
  2712  		success := "false"
  2713  		if err == nil {
  2714  			success = "true"
  2715  		}
  2716  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.DeleteForPost", success, elapsed)
  2717  	}
  2718  	return result, err
  2719  }
  2720  
  2721  func (s *TimerLayerFileInfoStore) Get(id string) (*model.FileInfo, error) {
  2722  	start := timemodule.Now()
  2723  
  2724  	result, err := s.FileInfoStore.Get(id)
  2725  
  2726  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2727  	if s.Root.Metrics != nil {
  2728  		success := "false"
  2729  		if err == nil {
  2730  			success = "true"
  2731  		}
  2732  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.Get", success, elapsed)
  2733  	}
  2734  	return result, err
  2735  }
  2736  
  2737  func (s *TimerLayerFileInfoStore) GetByIds(ids []string) ([]*model.FileInfo, error) {
  2738  	start := timemodule.Now()
  2739  
  2740  	result, err := s.FileInfoStore.GetByIds(ids)
  2741  
  2742  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2743  	if s.Root.Metrics != nil {
  2744  		success := "false"
  2745  		if err == nil {
  2746  			success = "true"
  2747  		}
  2748  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.GetByIds", success, elapsed)
  2749  	}
  2750  	return result, err
  2751  }
  2752  
  2753  func (s *TimerLayerFileInfoStore) GetByPath(path string) (*model.FileInfo, error) {
  2754  	start := timemodule.Now()
  2755  
  2756  	result, err := s.FileInfoStore.GetByPath(path)
  2757  
  2758  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2759  	if s.Root.Metrics != nil {
  2760  		success := "false"
  2761  		if err == nil {
  2762  			success = "true"
  2763  		}
  2764  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.GetByPath", success, elapsed)
  2765  	}
  2766  	return result, err
  2767  }
  2768  
  2769  func (s *TimerLayerFileInfoStore) GetForPost(postId string, readFromMaster bool, includeDeleted bool, allowFromCache bool) ([]*model.FileInfo, error) {
  2770  	start := timemodule.Now()
  2771  
  2772  	result, err := s.FileInfoStore.GetForPost(postId, readFromMaster, includeDeleted, allowFromCache)
  2773  
  2774  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2775  	if s.Root.Metrics != nil {
  2776  		success := "false"
  2777  		if err == nil {
  2778  			success = "true"
  2779  		}
  2780  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.GetForPost", success, elapsed)
  2781  	}
  2782  	return result, err
  2783  }
  2784  
  2785  func (s *TimerLayerFileInfoStore) GetForUser(userId string) ([]*model.FileInfo, error) {
  2786  	start := timemodule.Now()
  2787  
  2788  	result, err := s.FileInfoStore.GetForUser(userId)
  2789  
  2790  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2791  	if s.Root.Metrics != nil {
  2792  		success := "false"
  2793  		if err == nil {
  2794  			success = "true"
  2795  		}
  2796  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.GetForUser", success, elapsed)
  2797  	}
  2798  	return result, err
  2799  }
  2800  
  2801  func (s *TimerLayerFileInfoStore) GetWithOptions(page int, perPage int, opt *model.GetFileInfosOptions) ([]*model.FileInfo, error) {
  2802  	start := timemodule.Now()
  2803  
  2804  	result, err := s.FileInfoStore.GetWithOptions(page, perPage, opt)
  2805  
  2806  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2807  	if s.Root.Metrics != nil {
  2808  		success := "false"
  2809  		if err == nil {
  2810  			success = "true"
  2811  		}
  2812  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.GetWithOptions", success, elapsed)
  2813  	}
  2814  	return result, err
  2815  }
  2816  
  2817  func (s *TimerLayerFileInfoStore) InvalidateFileInfosForPostCache(postId string, deleted bool) {
  2818  	start := timemodule.Now()
  2819  
  2820  	s.FileInfoStore.InvalidateFileInfosForPostCache(postId, deleted)
  2821  
  2822  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2823  	if s.Root.Metrics != nil {
  2824  		success := "false"
  2825  		if true {
  2826  			success = "true"
  2827  		}
  2828  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.InvalidateFileInfosForPostCache", success, elapsed)
  2829  	}
  2830  }
  2831  
  2832  func (s *TimerLayerFileInfoStore) PermanentDelete(fileId string) error {
  2833  	start := timemodule.Now()
  2834  
  2835  	err := s.FileInfoStore.PermanentDelete(fileId)
  2836  
  2837  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2838  	if s.Root.Metrics != nil {
  2839  		success := "false"
  2840  		if err == nil {
  2841  			success = "true"
  2842  		}
  2843  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.PermanentDelete", success, elapsed)
  2844  	}
  2845  	return err
  2846  }
  2847  
  2848  func (s *TimerLayerFileInfoStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, error) {
  2849  	start := timemodule.Now()
  2850  
  2851  	result, err := s.FileInfoStore.PermanentDeleteBatch(endTime, limit)
  2852  
  2853  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2854  	if s.Root.Metrics != nil {
  2855  		success := "false"
  2856  		if err == nil {
  2857  			success = "true"
  2858  		}
  2859  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.PermanentDeleteBatch", success, elapsed)
  2860  	}
  2861  	return result, err
  2862  }
  2863  
  2864  func (s *TimerLayerFileInfoStore) PermanentDeleteByUser(userId string) (int64, error) {
  2865  	start := timemodule.Now()
  2866  
  2867  	result, err := s.FileInfoStore.PermanentDeleteByUser(userId)
  2868  
  2869  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2870  	if s.Root.Metrics != nil {
  2871  		success := "false"
  2872  		if err == nil {
  2873  			success = "true"
  2874  		}
  2875  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.PermanentDeleteByUser", success, elapsed)
  2876  	}
  2877  	return result, err
  2878  }
  2879  
  2880  func (s *TimerLayerFileInfoStore) Save(info *model.FileInfo) (*model.FileInfo, error) {
  2881  	start := timemodule.Now()
  2882  
  2883  	result, err := s.FileInfoStore.Save(info)
  2884  
  2885  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2886  	if s.Root.Metrics != nil {
  2887  		success := "false"
  2888  		if err == nil {
  2889  			success = "true"
  2890  		}
  2891  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.Save", success, elapsed)
  2892  	}
  2893  	return result, err
  2894  }
  2895  
  2896  func (s *TimerLayerFileInfoStore) Search(paramsList []*model.SearchParams, userId string, teamId string, page int, perPage int) (*model.FileInfoList, error) {
  2897  	start := timemodule.Now()
  2898  
  2899  	result, err := s.FileInfoStore.Search(paramsList, userId, teamId, page, perPage)
  2900  
  2901  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2902  	if s.Root.Metrics != nil {
  2903  		success := "false"
  2904  		if err == nil {
  2905  			success = "true"
  2906  		}
  2907  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.Search", success, elapsed)
  2908  	}
  2909  	return result, err
  2910  }
  2911  
  2912  func (s *TimerLayerFileInfoStore) SetContent(fileId string, content string) error {
  2913  	start := timemodule.Now()
  2914  
  2915  	err := s.FileInfoStore.SetContent(fileId, content)
  2916  
  2917  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2918  	if s.Root.Metrics != nil {
  2919  		success := "false"
  2920  		if err == nil {
  2921  			success = "true"
  2922  		}
  2923  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.SetContent", success, elapsed)
  2924  	}
  2925  	return err
  2926  }
  2927  
  2928  func (s *TimerLayerFileInfoStore) Upsert(info *model.FileInfo) (*model.FileInfo, error) {
  2929  	start := timemodule.Now()
  2930  
  2931  	result, err := s.FileInfoStore.Upsert(info)
  2932  
  2933  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2934  	if s.Root.Metrics != nil {
  2935  		success := "false"
  2936  		if err == nil {
  2937  			success = "true"
  2938  		}
  2939  		s.Root.Metrics.ObserveStoreMethodDuration("FileInfoStore.Upsert", success, elapsed)
  2940  	}
  2941  	return result, err
  2942  }
  2943  
  2944  func (s *TimerLayerGroupStore) AdminRoleGroupsForSyncableMember(userID string, syncableID string, syncableType model.GroupSyncableType) ([]string, error) {
  2945  	start := timemodule.Now()
  2946  
  2947  	result, err := s.GroupStore.AdminRoleGroupsForSyncableMember(userID, syncableID, syncableType)
  2948  
  2949  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2950  	if s.Root.Metrics != nil {
  2951  		success := "false"
  2952  		if err == nil {
  2953  			success = "true"
  2954  		}
  2955  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.AdminRoleGroupsForSyncableMember", success, elapsed)
  2956  	}
  2957  	return result, err
  2958  }
  2959  
  2960  func (s *TimerLayerGroupStore) ChannelMembersMinusGroupMembers(channelID string, groupIDs []string, page int, perPage int) ([]*model.UserWithGroups, error) {
  2961  	start := timemodule.Now()
  2962  
  2963  	result, err := s.GroupStore.ChannelMembersMinusGroupMembers(channelID, groupIDs, page, perPage)
  2964  
  2965  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2966  	if s.Root.Metrics != nil {
  2967  		success := "false"
  2968  		if err == nil {
  2969  			success = "true"
  2970  		}
  2971  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.ChannelMembersMinusGroupMembers", success, elapsed)
  2972  	}
  2973  	return result, err
  2974  }
  2975  
  2976  func (s *TimerLayerGroupStore) ChannelMembersToAdd(since int64, channelID *string) ([]*model.UserChannelIDPair, error) {
  2977  	start := timemodule.Now()
  2978  
  2979  	result, err := s.GroupStore.ChannelMembersToAdd(since, channelID)
  2980  
  2981  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2982  	if s.Root.Metrics != nil {
  2983  		success := "false"
  2984  		if err == nil {
  2985  			success = "true"
  2986  		}
  2987  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.ChannelMembersToAdd", success, elapsed)
  2988  	}
  2989  	return result, err
  2990  }
  2991  
  2992  func (s *TimerLayerGroupStore) ChannelMembersToRemove(channelID *string) ([]*model.ChannelMember, error) {
  2993  	start := timemodule.Now()
  2994  
  2995  	result, err := s.GroupStore.ChannelMembersToRemove(channelID)
  2996  
  2997  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  2998  	if s.Root.Metrics != nil {
  2999  		success := "false"
  3000  		if err == nil {
  3001  			success = "true"
  3002  		}
  3003  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.ChannelMembersToRemove", success, elapsed)
  3004  	}
  3005  	return result, err
  3006  }
  3007  
  3008  func (s *TimerLayerGroupStore) CountChannelMembersMinusGroupMembers(channelID string, groupIDs []string) (int64, error) {
  3009  	start := timemodule.Now()
  3010  
  3011  	result, err := s.GroupStore.CountChannelMembersMinusGroupMembers(channelID, groupIDs)
  3012  
  3013  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3014  	if s.Root.Metrics != nil {
  3015  		success := "false"
  3016  		if err == nil {
  3017  			success = "true"
  3018  		}
  3019  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.CountChannelMembersMinusGroupMembers", success, elapsed)
  3020  	}
  3021  	return result, err
  3022  }
  3023  
  3024  func (s *TimerLayerGroupStore) CountGroupsByChannel(channelId string, opts model.GroupSearchOpts) (int64, error) {
  3025  	start := timemodule.Now()
  3026  
  3027  	result, err := s.GroupStore.CountGroupsByChannel(channelId, opts)
  3028  
  3029  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3030  	if s.Root.Metrics != nil {
  3031  		success := "false"
  3032  		if err == nil {
  3033  			success = "true"
  3034  		}
  3035  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.CountGroupsByChannel", success, elapsed)
  3036  	}
  3037  	return result, err
  3038  }
  3039  
  3040  func (s *TimerLayerGroupStore) CountGroupsByTeam(teamId string, opts model.GroupSearchOpts) (int64, error) {
  3041  	start := timemodule.Now()
  3042  
  3043  	result, err := s.GroupStore.CountGroupsByTeam(teamId, opts)
  3044  
  3045  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3046  	if s.Root.Metrics != nil {
  3047  		success := "false"
  3048  		if err == nil {
  3049  			success = "true"
  3050  		}
  3051  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.CountGroupsByTeam", success, elapsed)
  3052  	}
  3053  	return result, err
  3054  }
  3055  
  3056  func (s *TimerLayerGroupStore) CountTeamMembersMinusGroupMembers(teamID string, groupIDs []string) (int64, error) {
  3057  	start := timemodule.Now()
  3058  
  3059  	result, err := s.GroupStore.CountTeamMembersMinusGroupMembers(teamID, groupIDs)
  3060  
  3061  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3062  	if s.Root.Metrics != nil {
  3063  		success := "false"
  3064  		if err == nil {
  3065  			success = "true"
  3066  		}
  3067  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.CountTeamMembersMinusGroupMembers", success, elapsed)
  3068  	}
  3069  	return result, err
  3070  }
  3071  
  3072  func (s *TimerLayerGroupStore) Create(group *model.Group) (*model.Group, error) {
  3073  	start := timemodule.Now()
  3074  
  3075  	result, err := s.GroupStore.Create(group)
  3076  
  3077  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3078  	if s.Root.Metrics != nil {
  3079  		success := "false"
  3080  		if err == nil {
  3081  			success = "true"
  3082  		}
  3083  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.Create", success, elapsed)
  3084  	}
  3085  	return result, err
  3086  }
  3087  
  3088  func (s *TimerLayerGroupStore) CreateGroupSyncable(groupSyncable *model.GroupSyncable) (*model.GroupSyncable, error) {
  3089  	start := timemodule.Now()
  3090  
  3091  	result, err := s.GroupStore.CreateGroupSyncable(groupSyncable)
  3092  
  3093  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3094  	if s.Root.Metrics != nil {
  3095  		success := "false"
  3096  		if err == nil {
  3097  			success = "true"
  3098  		}
  3099  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.CreateGroupSyncable", success, elapsed)
  3100  	}
  3101  	return result, err
  3102  }
  3103  
  3104  func (s *TimerLayerGroupStore) Delete(groupID string) (*model.Group, error) {
  3105  	start := timemodule.Now()
  3106  
  3107  	result, err := s.GroupStore.Delete(groupID)
  3108  
  3109  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3110  	if s.Root.Metrics != nil {
  3111  		success := "false"
  3112  		if err == nil {
  3113  			success = "true"
  3114  		}
  3115  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.Delete", success, elapsed)
  3116  	}
  3117  	return result, err
  3118  }
  3119  
  3120  func (s *TimerLayerGroupStore) DeleteGroupSyncable(groupID string, syncableID string, syncableType model.GroupSyncableType) (*model.GroupSyncable, error) {
  3121  	start := timemodule.Now()
  3122  
  3123  	result, err := s.GroupStore.DeleteGroupSyncable(groupID, syncableID, syncableType)
  3124  
  3125  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3126  	if s.Root.Metrics != nil {
  3127  		success := "false"
  3128  		if err == nil {
  3129  			success = "true"
  3130  		}
  3131  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.DeleteGroupSyncable", success, elapsed)
  3132  	}
  3133  	return result, err
  3134  }
  3135  
  3136  func (s *TimerLayerGroupStore) DeleteMember(groupID string, userID string) (*model.GroupMember, error) {
  3137  	start := timemodule.Now()
  3138  
  3139  	result, err := s.GroupStore.DeleteMember(groupID, userID)
  3140  
  3141  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3142  	if s.Root.Metrics != nil {
  3143  		success := "false"
  3144  		if err == nil {
  3145  			success = "true"
  3146  		}
  3147  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.DeleteMember", success, elapsed)
  3148  	}
  3149  	return result, err
  3150  }
  3151  
  3152  func (s *TimerLayerGroupStore) DistinctGroupMemberCount() (int64, error) {
  3153  	start := timemodule.Now()
  3154  
  3155  	result, err := s.GroupStore.DistinctGroupMemberCount()
  3156  
  3157  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3158  	if s.Root.Metrics != nil {
  3159  		success := "false"
  3160  		if err == nil {
  3161  			success = "true"
  3162  		}
  3163  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.DistinctGroupMemberCount", success, elapsed)
  3164  	}
  3165  	return result, err
  3166  }
  3167  
  3168  func (s *TimerLayerGroupStore) Get(groupID string) (*model.Group, error) {
  3169  	start := timemodule.Now()
  3170  
  3171  	result, err := s.GroupStore.Get(groupID)
  3172  
  3173  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3174  	if s.Root.Metrics != nil {
  3175  		success := "false"
  3176  		if err == nil {
  3177  			success = "true"
  3178  		}
  3179  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.Get", success, elapsed)
  3180  	}
  3181  	return result, err
  3182  }
  3183  
  3184  func (s *TimerLayerGroupStore) GetAllBySource(groupSource model.GroupSource) ([]*model.Group, error) {
  3185  	start := timemodule.Now()
  3186  
  3187  	result, err := s.GroupStore.GetAllBySource(groupSource)
  3188  
  3189  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3190  	if s.Root.Metrics != nil {
  3191  		success := "false"
  3192  		if err == nil {
  3193  			success = "true"
  3194  		}
  3195  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetAllBySource", success, elapsed)
  3196  	}
  3197  	return result, err
  3198  }
  3199  
  3200  func (s *TimerLayerGroupStore) GetAllGroupSyncablesByGroupId(groupID string, syncableType model.GroupSyncableType) ([]*model.GroupSyncable, error) {
  3201  	start := timemodule.Now()
  3202  
  3203  	result, err := s.GroupStore.GetAllGroupSyncablesByGroupId(groupID, syncableType)
  3204  
  3205  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3206  	if s.Root.Metrics != nil {
  3207  		success := "false"
  3208  		if err == nil {
  3209  			success = "true"
  3210  		}
  3211  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetAllGroupSyncablesByGroupId", success, elapsed)
  3212  	}
  3213  	return result, err
  3214  }
  3215  
  3216  func (s *TimerLayerGroupStore) GetByIDs(groupIDs []string) ([]*model.Group, error) {
  3217  	start := timemodule.Now()
  3218  
  3219  	result, err := s.GroupStore.GetByIDs(groupIDs)
  3220  
  3221  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3222  	if s.Root.Metrics != nil {
  3223  		success := "false"
  3224  		if err == nil {
  3225  			success = "true"
  3226  		}
  3227  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetByIDs", success, elapsed)
  3228  	}
  3229  	return result, err
  3230  }
  3231  
  3232  func (s *TimerLayerGroupStore) GetByName(name string, opts model.GroupSearchOpts) (*model.Group, error) {
  3233  	start := timemodule.Now()
  3234  
  3235  	result, err := s.GroupStore.GetByName(name, opts)
  3236  
  3237  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3238  	if s.Root.Metrics != nil {
  3239  		success := "false"
  3240  		if err == nil {
  3241  			success = "true"
  3242  		}
  3243  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetByName", success, elapsed)
  3244  	}
  3245  	return result, err
  3246  }
  3247  
  3248  func (s *TimerLayerGroupStore) GetByRemoteID(remoteID string, groupSource model.GroupSource) (*model.Group, error) {
  3249  	start := timemodule.Now()
  3250  
  3251  	result, err := s.GroupStore.GetByRemoteID(remoteID, groupSource)
  3252  
  3253  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3254  	if s.Root.Metrics != nil {
  3255  		success := "false"
  3256  		if err == nil {
  3257  			success = "true"
  3258  		}
  3259  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetByRemoteID", success, elapsed)
  3260  	}
  3261  	return result, err
  3262  }
  3263  
  3264  func (s *TimerLayerGroupStore) GetByUser(userId string) ([]*model.Group, error) {
  3265  	start := timemodule.Now()
  3266  
  3267  	result, err := s.GroupStore.GetByUser(userId)
  3268  
  3269  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3270  	if s.Root.Metrics != nil {
  3271  		success := "false"
  3272  		if err == nil {
  3273  			success = "true"
  3274  		}
  3275  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetByUser", success, elapsed)
  3276  	}
  3277  	return result, err
  3278  }
  3279  
  3280  func (s *TimerLayerGroupStore) GetGroupSyncable(groupID string, syncableID string, syncableType model.GroupSyncableType) (*model.GroupSyncable, error) {
  3281  	start := timemodule.Now()
  3282  
  3283  	result, err := s.GroupStore.GetGroupSyncable(groupID, syncableID, syncableType)
  3284  
  3285  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3286  	if s.Root.Metrics != nil {
  3287  		success := "false"
  3288  		if err == nil {
  3289  			success = "true"
  3290  		}
  3291  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetGroupSyncable", success, elapsed)
  3292  	}
  3293  	return result, err
  3294  }
  3295  
  3296  func (s *TimerLayerGroupStore) GetGroups(page int, perPage int, opts model.GroupSearchOpts) ([]*model.Group, error) {
  3297  	start := timemodule.Now()
  3298  
  3299  	result, err := s.GroupStore.GetGroups(page, perPage, opts)
  3300  
  3301  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3302  	if s.Root.Metrics != nil {
  3303  		success := "false"
  3304  		if err == nil {
  3305  			success = "true"
  3306  		}
  3307  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetGroups", success, elapsed)
  3308  	}
  3309  	return result, err
  3310  }
  3311  
  3312  func (s *TimerLayerGroupStore) GetGroupsAssociatedToChannelsByTeam(teamId string, opts model.GroupSearchOpts) (map[string][]*model.GroupWithSchemeAdmin, error) {
  3313  	start := timemodule.Now()
  3314  
  3315  	result, err := s.GroupStore.GetGroupsAssociatedToChannelsByTeam(teamId, opts)
  3316  
  3317  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3318  	if s.Root.Metrics != nil {
  3319  		success := "false"
  3320  		if err == nil {
  3321  			success = "true"
  3322  		}
  3323  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetGroupsAssociatedToChannelsByTeam", success, elapsed)
  3324  	}
  3325  	return result, err
  3326  }
  3327  
  3328  func (s *TimerLayerGroupStore) GetGroupsByChannel(channelId string, opts model.GroupSearchOpts) ([]*model.GroupWithSchemeAdmin, error) {
  3329  	start := timemodule.Now()
  3330  
  3331  	result, err := s.GroupStore.GetGroupsByChannel(channelId, opts)
  3332  
  3333  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3334  	if s.Root.Metrics != nil {
  3335  		success := "false"
  3336  		if err == nil {
  3337  			success = "true"
  3338  		}
  3339  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetGroupsByChannel", success, elapsed)
  3340  	}
  3341  	return result, err
  3342  }
  3343  
  3344  func (s *TimerLayerGroupStore) GetGroupsByTeam(teamId string, opts model.GroupSearchOpts) ([]*model.GroupWithSchemeAdmin, error) {
  3345  	start := timemodule.Now()
  3346  
  3347  	result, err := s.GroupStore.GetGroupsByTeam(teamId, opts)
  3348  
  3349  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3350  	if s.Root.Metrics != nil {
  3351  		success := "false"
  3352  		if err == nil {
  3353  			success = "true"
  3354  		}
  3355  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetGroupsByTeam", success, elapsed)
  3356  	}
  3357  	return result, err
  3358  }
  3359  
  3360  func (s *TimerLayerGroupStore) GetMemberCount(groupID string) (int64, error) {
  3361  	start := timemodule.Now()
  3362  
  3363  	result, err := s.GroupStore.GetMemberCount(groupID)
  3364  
  3365  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3366  	if s.Root.Metrics != nil {
  3367  		success := "false"
  3368  		if err == nil {
  3369  			success = "true"
  3370  		}
  3371  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetMemberCount", success, elapsed)
  3372  	}
  3373  	return result, err
  3374  }
  3375  
  3376  func (s *TimerLayerGroupStore) GetMemberUsers(groupID string) ([]*model.User, error) {
  3377  	start := timemodule.Now()
  3378  
  3379  	result, err := s.GroupStore.GetMemberUsers(groupID)
  3380  
  3381  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3382  	if s.Root.Metrics != nil {
  3383  		success := "false"
  3384  		if err == nil {
  3385  			success = "true"
  3386  		}
  3387  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetMemberUsers", success, elapsed)
  3388  	}
  3389  	return result, err
  3390  }
  3391  
  3392  func (s *TimerLayerGroupStore) GetMemberUsersInTeam(groupID string, teamID string) ([]*model.User, error) {
  3393  	start := timemodule.Now()
  3394  
  3395  	result, err := s.GroupStore.GetMemberUsersInTeam(groupID, teamID)
  3396  
  3397  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3398  	if s.Root.Metrics != nil {
  3399  		success := "false"
  3400  		if err == nil {
  3401  			success = "true"
  3402  		}
  3403  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetMemberUsersInTeam", success, elapsed)
  3404  	}
  3405  	return result, err
  3406  }
  3407  
  3408  func (s *TimerLayerGroupStore) GetMemberUsersNotInChannel(groupID string, channelID string) ([]*model.User, error) {
  3409  	start := timemodule.Now()
  3410  
  3411  	result, err := s.GroupStore.GetMemberUsersNotInChannel(groupID, channelID)
  3412  
  3413  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3414  	if s.Root.Metrics != nil {
  3415  		success := "false"
  3416  		if err == nil {
  3417  			success = "true"
  3418  		}
  3419  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetMemberUsersNotInChannel", success, elapsed)
  3420  	}
  3421  	return result, err
  3422  }
  3423  
  3424  func (s *TimerLayerGroupStore) GetMemberUsersPage(groupID string, page int, perPage int) ([]*model.User, error) {
  3425  	start := timemodule.Now()
  3426  
  3427  	result, err := s.GroupStore.GetMemberUsersPage(groupID, page, perPage)
  3428  
  3429  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3430  	if s.Root.Metrics != nil {
  3431  		success := "false"
  3432  		if err == nil {
  3433  			success = "true"
  3434  		}
  3435  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GetMemberUsersPage", success, elapsed)
  3436  	}
  3437  	return result, err
  3438  }
  3439  
  3440  func (s *TimerLayerGroupStore) GroupChannelCount() (int64, error) {
  3441  	start := timemodule.Now()
  3442  
  3443  	result, err := s.GroupStore.GroupChannelCount()
  3444  
  3445  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3446  	if s.Root.Metrics != nil {
  3447  		success := "false"
  3448  		if err == nil {
  3449  			success = "true"
  3450  		}
  3451  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GroupChannelCount", success, elapsed)
  3452  	}
  3453  	return result, err
  3454  }
  3455  
  3456  func (s *TimerLayerGroupStore) GroupCount() (int64, error) {
  3457  	start := timemodule.Now()
  3458  
  3459  	result, err := s.GroupStore.GroupCount()
  3460  
  3461  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3462  	if s.Root.Metrics != nil {
  3463  		success := "false"
  3464  		if err == nil {
  3465  			success = "true"
  3466  		}
  3467  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GroupCount", success, elapsed)
  3468  	}
  3469  	return result, err
  3470  }
  3471  
  3472  func (s *TimerLayerGroupStore) GroupCountWithAllowReference() (int64, error) {
  3473  	start := timemodule.Now()
  3474  
  3475  	result, err := s.GroupStore.GroupCountWithAllowReference()
  3476  
  3477  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3478  	if s.Root.Metrics != nil {
  3479  		success := "false"
  3480  		if err == nil {
  3481  			success = "true"
  3482  		}
  3483  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GroupCountWithAllowReference", success, elapsed)
  3484  	}
  3485  	return result, err
  3486  }
  3487  
  3488  func (s *TimerLayerGroupStore) GroupMemberCount() (int64, error) {
  3489  	start := timemodule.Now()
  3490  
  3491  	result, err := s.GroupStore.GroupMemberCount()
  3492  
  3493  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3494  	if s.Root.Metrics != nil {
  3495  		success := "false"
  3496  		if err == nil {
  3497  			success = "true"
  3498  		}
  3499  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GroupMemberCount", success, elapsed)
  3500  	}
  3501  	return result, err
  3502  }
  3503  
  3504  func (s *TimerLayerGroupStore) GroupTeamCount() (int64, error) {
  3505  	start := timemodule.Now()
  3506  
  3507  	result, err := s.GroupStore.GroupTeamCount()
  3508  
  3509  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3510  	if s.Root.Metrics != nil {
  3511  		success := "false"
  3512  		if err == nil {
  3513  			success = "true"
  3514  		}
  3515  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.GroupTeamCount", success, elapsed)
  3516  	}
  3517  	return result, err
  3518  }
  3519  
  3520  func (s *TimerLayerGroupStore) PermanentDeleteMembersByUser(userId string) error {
  3521  	start := timemodule.Now()
  3522  
  3523  	err := s.GroupStore.PermanentDeleteMembersByUser(userId)
  3524  
  3525  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3526  	if s.Root.Metrics != nil {
  3527  		success := "false"
  3528  		if err == nil {
  3529  			success = "true"
  3530  		}
  3531  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.PermanentDeleteMembersByUser", success, elapsed)
  3532  	}
  3533  	return err
  3534  }
  3535  
  3536  func (s *TimerLayerGroupStore) PermittedSyncableAdmins(syncableID string, syncableType model.GroupSyncableType) ([]string, error) {
  3537  	start := timemodule.Now()
  3538  
  3539  	result, err := s.GroupStore.PermittedSyncableAdmins(syncableID, syncableType)
  3540  
  3541  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3542  	if s.Root.Metrics != nil {
  3543  		success := "false"
  3544  		if err == nil {
  3545  			success = "true"
  3546  		}
  3547  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.PermittedSyncableAdmins", success, elapsed)
  3548  	}
  3549  	return result, err
  3550  }
  3551  
  3552  func (s *TimerLayerGroupStore) TeamMembersMinusGroupMembers(teamID string, groupIDs []string, page int, perPage int) ([]*model.UserWithGroups, error) {
  3553  	start := timemodule.Now()
  3554  
  3555  	result, err := s.GroupStore.TeamMembersMinusGroupMembers(teamID, groupIDs, page, perPage)
  3556  
  3557  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3558  	if s.Root.Metrics != nil {
  3559  		success := "false"
  3560  		if err == nil {
  3561  			success = "true"
  3562  		}
  3563  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.TeamMembersMinusGroupMembers", success, elapsed)
  3564  	}
  3565  	return result, err
  3566  }
  3567  
  3568  func (s *TimerLayerGroupStore) TeamMembersToAdd(since int64, teamID *string) ([]*model.UserTeamIDPair, error) {
  3569  	start := timemodule.Now()
  3570  
  3571  	result, err := s.GroupStore.TeamMembersToAdd(since, teamID)
  3572  
  3573  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3574  	if s.Root.Metrics != nil {
  3575  		success := "false"
  3576  		if err == nil {
  3577  			success = "true"
  3578  		}
  3579  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.TeamMembersToAdd", success, elapsed)
  3580  	}
  3581  	return result, err
  3582  }
  3583  
  3584  func (s *TimerLayerGroupStore) TeamMembersToRemove(teamID *string) ([]*model.TeamMember, error) {
  3585  	start := timemodule.Now()
  3586  
  3587  	result, err := s.GroupStore.TeamMembersToRemove(teamID)
  3588  
  3589  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3590  	if s.Root.Metrics != nil {
  3591  		success := "false"
  3592  		if err == nil {
  3593  			success = "true"
  3594  		}
  3595  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.TeamMembersToRemove", success, elapsed)
  3596  	}
  3597  	return result, err
  3598  }
  3599  
  3600  func (s *TimerLayerGroupStore) Update(group *model.Group) (*model.Group, error) {
  3601  	start := timemodule.Now()
  3602  
  3603  	result, err := s.GroupStore.Update(group)
  3604  
  3605  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3606  	if s.Root.Metrics != nil {
  3607  		success := "false"
  3608  		if err == nil {
  3609  			success = "true"
  3610  		}
  3611  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.Update", success, elapsed)
  3612  	}
  3613  	return result, err
  3614  }
  3615  
  3616  func (s *TimerLayerGroupStore) UpdateGroupSyncable(groupSyncable *model.GroupSyncable) (*model.GroupSyncable, error) {
  3617  	start := timemodule.Now()
  3618  
  3619  	result, err := s.GroupStore.UpdateGroupSyncable(groupSyncable)
  3620  
  3621  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3622  	if s.Root.Metrics != nil {
  3623  		success := "false"
  3624  		if err == nil {
  3625  			success = "true"
  3626  		}
  3627  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.UpdateGroupSyncable", success, elapsed)
  3628  	}
  3629  	return result, err
  3630  }
  3631  
  3632  func (s *TimerLayerGroupStore) UpsertMember(groupID string, userID string) (*model.GroupMember, error) {
  3633  	start := timemodule.Now()
  3634  
  3635  	result, err := s.GroupStore.UpsertMember(groupID, userID)
  3636  
  3637  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3638  	if s.Root.Metrics != nil {
  3639  		success := "false"
  3640  		if err == nil {
  3641  			success = "true"
  3642  		}
  3643  		s.Root.Metrics.ObserveStoreMethodDuration("GroupStore.UpsertMember", success, elapsed)
  3644  	}
  3645  	return result, err
  3646  }
  3647  
  3648  func (s *TimerLayerJobStore) Delete(id string) (string, error) {
  3649  	start := timemodule.Now()
  3650  
  3651  	result, err := s.JobStore.Delete(id)
  3652  
  3653  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3654  	if s.Root.Metrics != nil {
  3655  		success := "false"
  3656  		if err == nil {
  3657  			success = "true"
  3658  		}
  3659  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.Delete", success, elapsed)
  3660  	}
  3661  	return result, err
  3662  }
  3663  
  3664  func (s *TimerLayerJobStore) Get(id string) (*model.Job, error) {
  3665  	start := timemodule.Now()
  3666  
  3667  	result, err := s.JobStore.Get(id)
  3668  
  3669  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3670  	if s.Root.Metrics != nil {
  3671  		success := "false"
  3672  		if err == nil {
  3673  			success = "true"
  3674  		}
  3675  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.Get", success, elapsed)
  3676  	}
  3677  	return result, err
  3678  }
  3679  
  3680  func (s *TimerLayerJobStore) GetAllByStatus(status string) ([]*model.Job, error) {
  3681  	start := timemodule.Now()
  3682  
  3683  	result, err := s.JobStore.GetAllByStatus(status)
  3684  
  3685  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3686  	if s.Root.Metrics != nil {
  3687  		success := "false"
  3688  		if err == nil {
  3689  			success = "true"
  3690  		}
  3691  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetAllByStatus", success, elapsed)
  3692  	}
  3693  	return result, err
  3694  }
  3695  
  3696  func (s *TimerLayerJobStore) GetAllByType(jobType string) ([]*model.Job, error) {
  3697  	start := timemodule.Now()
  3698  
  3699  	result, err := s.JobStore.GetAllByType(jobType)
  3700  
  3701  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3702  	if s.Root.Metrics != nil {
  3703  		success := "false"
  3704  		if err == nil {
  3705  			success = "true"
  3706  		}
  3707  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetAllByType", success, elapsed)
  3708  	}
  3709  	return result, err
  3710  }
  3711  
  3712  func (s *TimerLayerJobStore) GetAllByTypePage(jobType string, offset int, limit int) ([]*model.Job, error) {
  3713  	start := timemodule.Now()
  3714  
  3715  	result, err := s.JobStore.GetAllByTypePage(jobType, offset, limit)
  3716  
  3717  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3718  	if s.Root.Metrics != nil {
  3719  		success := "false"
  3720  		if err == nil {
  3721  			success = "true"
  3722  		}
  3723  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetAllByTypePage", success, elapsed)
  3724  	}
  3725  	return result, err
  3726  }
  3727  
  3728  func (s *TimerLayerJobStore) GetAllPage(offset int, limit int) ([]*model.Job, error) {
  3729  	start := timemodule.Now()
  3730  
  3731  	result, err := s.JobStore.GetAllPage(offset, limit)
  3732  
  3733  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3734  	if s.Root.Metrics != nil {
  3735  		success := "false"
  3736  		if err == nil {
  3737  			success = "true"
  3738  		}
  3739  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetAllPage", success, elapsed)
  3740  	}
  3741  	return result, err
  3742  }
  3743  
  3744  func (s *TimerLayerJobStore) GetCountByStatusAndType(status string, jobType string) (int64, error) {
  3745  	start := timemodule.Now()
  3746  
  3747  	result, err := s.JobStore.GetCountByStatusAndType(status, jobType)
  3748  
  3749  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3750  	if s.Root.Metrics != nil {
  3751  		success := "false"
  3752  		if err == nil {
  3753  			success = "true"
  3754  		}
  3755  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetCountByStatusAndType", success, elapsed)
  3756  	}
  3757  	return result, err
  3758  }
  3759  
  3760  func (s *TimerLayerJobStore) GetNewestJobByStatusAndType(status string, jobType string) (*model.Job, error) {
  3761  	start := timemodule.Now()
  3762  
  3763  	result, err := s.JobStore.GetNewestJobByStatusAndType(status, jobType)
  3764  
  3765  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3766  	if s.Root.Metrics != nil {
  3767  		success := "false"
  3768  		if err == nil {
  3769  			success = "true"
  3770  		}
  3771  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetNewestJobByStatusAndType", success, elapsed)
  3772  	}
  3773  	return result, err
  3774  }
  3775  
  3776  func (s *TimerLayerJobStore) GetNewestJobByStatusesAndType(statuses []string, jobType string) (*model.Job, error) {
  3777  	start := timemodule.Now()
  3778  
  3779  	result, err := s.JobStore.GetNewestJobByStatusesAndType(statuses, jobType)
  3780  
  3781  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3782  	if s.Root.Metrics != nil {
  3783  		success := "false"
  3784  		if err == nil {
  3785  			success = "true"
  3786  		}
  3787  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.GetNewestJobByStatusesAndType", success, elapsed)
  3788  	}
  3789  	return result, err
  3790  }
  3791  
  3792  func (s *TimerLayerJobStore) Save(job *model.Job) (*model.Job, error) {
  3793  	start := timemodule.Now()
  3794  
  3795  	result, err := s.JobStore.Save(job)
  3796  
  3797  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3798  	if s.Root.Metrics != nil {
  3799  		success := "false"
  3800  		if err == nil {
  3801  			success = "true"
  3802  		}
  3803  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.Save", success, elapsed)
  3804  	}
  3805  	return result, err
  3806  }
  3807  
  3808  func (s *TimerLayerJobStore) UpdateOptimistically(job *model.Job, currentStatus string) (bool, error) {
  3809  	start := timemodule.Now()
  3810  
  3811  	result, err := s.JobStore.UpdateOptimistically(job, currentStatus)
  3812  
  3813  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3814  	if s.Root.Metrics != nil {
  3815  		success := "false"
  3816  		if err == nil {
  3817  			success = "true"
  3818  		}
  3819  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.UpdateOptimistically", success, elapsed)
  3820  	}
  3821  	return result, err
  3822  }
  3823  
  3824  func (s *TimerLayerJobStore) UpdateStatus(id string, status string) (*model.Job, error) {
  3825  	start := timemodule.Now()
  3826  
  3827  	result, err := s.JobStore.UpdateStatus(id, status)
  3828  
  3829  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3830  	if s.Root.Metrics != nil {
  3831  		success := "false"
  3832  		if err == nil {
  3833  			success = "true"
  3834  		}
  3835  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.UpdateStatus", success, elapsed)
  3836  	}
  3837  	return result, err
  3838  }
  3839  
  3840  func (s *TimerLayerJobStore) UpdateStatusOptimistically(id string, currentStatus string, newStatus string) (bool, error) {
  3841  	start := timemodule.Now()
  3842  
  3843  	result, err := s.JobStore.UpdateStatusOptimistically(id, currentStatus, newStatus)
  3844  
  3845  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3846  	if s.Root.Metrics != nil {
  3847  		success := "false"
  3848  		if err == nil {
  3849  			success = "true"
  3850  		}
  3851  		s.Root.Metrics.ObserveStoreMethodDuration("JobStore.UpdateStatusOptimistically", success, elapsed)
  3852  	}
  3853  	return result, err
  3854  }
  3855  
  3856  func (s *TimerLayerLicenseStore) Get(id string) (*model.LicenseRecord, error) {
  3857  	start := timemodule.Now()
  3858  
  3859  	result, err := s.LicenseStore.Get(id)
  3860  
  3861  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3862  	if s.Root.Metrics != nil {
  3863  		success := "false"
  3864  		if err == nil {
  3865  			success = "true"
  3866  		}
  3867  		s.Root.Metrics.ObserveStoreMethodDuration("LicenseStore.Get", success, elapsed)
  3868  	}
  3869  	return result, err
  3870  }
  3871  
  3872  func (s *TimerLayerLicenseStore) Save(license *model.LicenseRecord) (*model.LicenseRecord, error) {
  3873  	start := timemodule.Now()
  3874  
  3875  	result, err := s.LicenseStore.Save(license)
  3876  
  3877  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3878  	if s.Root.Metrics != nil {
  3879  		success := "false"
  3880  		if err == nil {
  3881  			success = "true"
  3882  		}
  3883  		s.Root.Metrics.ObserveStoreMethodDuration("LicenseStore.Save", success, elapsed)
  3884  	}
  3885  	return result, err
  3886  }
  3887  
  3888  func (s *TimerLayerLinkMetadataStore) Get(url string, timestamp int64) (*model.LinkMetadata, error) {
  3889  	start := timemodule.Now()
  3890  
  3891  	result, err := s.LinkMetadataStore.Get(url, timestamp)
  3892  
  3893  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3894  	if s.Root.Metrics != nil {
  3895  		success := "false"
  3896  		if err == nil {
  3897  			success = "true"
  3898  		}
  3899  		s.Root.Metrics.ObserveStoreMethodDuration("LinkMetadataStore.Get", success, elapsed)
  3900  	}
  3901  	return result, err
  3902  }
  3903  
  3904  func (s *TimerLayerLinkMetadataStore) Save(linkMetadata *model.LinkMetadata) (*model.LinkMetadata, error) {
  3905  	start := timemodule.Now()
  3906  
  3907  	result, err := s.LinkMetadataStore.Save(linkMetadata)
  3908  
  3909  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3910  	if s.Root.Metrics != nil {
  3911  		success := "false"
  3912  		if err == nil {
  3913  			success = "true"
  3914  		}
  3915  		s.Root.Metrics.ObserveStoreMethodDuration("LinkMetadataStore.Save", success, elapsed)
  3916  	}
  3917  	return result, err
  3918  }
  3919  
  3920  func (s *TimerLayerOAuthStore) DeleteApp(id string) error {
  3921  	start := timemodule.Now()
  3922  
  3923  	err := s.OAuthStore.DeleteApp(id)
  3924  
  3925  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3926  	if s.Root.Metrics != nil {
  3927  		success := "false"
  3928  		if err == nil {
  3929  			success = "true"
  3930  		}
  3931  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.DeleteApp", success, elapsed)
  3932  	}
  3933  	return err
  3934  }
  3935  
  3936  func (s *TimerLayerOAuthStore) GetAccessData(token string) (*model.AccessData, error) {
  3937  	start := timemodule.Now()
  3938  
  3939  	result, err := s.OAuthStore.GetAccessData(token)
  3940  
  3941  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3942  	if s.Root.Metrics != nil {
  3943  		success := "false"
  3944  		if err == nil {
  3945  			success = "true"
  3946  		}
  3947  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetAccessData", success, elapsed)
  3948  	}
  3949  	return result, err
  3950  }
  3951  
  3952  func (s *TimerLayerOAuthStore) GetAccessDataByRefreshToken(token string) (*model.AccessData, error) {
  3953  	start := timemodule.Now()
  3954  
  3955  	result, err := s.OAuthStore.GetAccessDataByRefreshToken(token)
  3956  
  3957  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3958  	if s.Root.Metrics != nil {
  3959  		success := "false"
  3960  		if err == nil {
  3961  			success = "true"
  3962  		}
  3963  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetAccessDataByRefreshToken", success, elapsed)
  3964  	}
  3965  	return result, err
  3966  }
  3967  
  3968  func (s *TimerLayerOAuthStore) GetAccessDataByUserForApp(userId string, clientId string) ([]*model.AccessData, error) {
  3969  	start := timemodule.Now()
  3970  
  3971  	result, err := s.OAuthStore.GetAccessDataByUserForApp(userId, clientId)
  3972  
  3973  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3974  	if s.Root.Metrics != nil {
  3975  		success := "false"
  3976  		if err == nil {
  3977  			success = "true"
  3978  		}
  3979  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetAccessDataByUserForApp", success, elapsed)
  3980  	}
  3981  	return result, err
  3982  }
  3983  
  3984  func (s *TimerLayerOAuthStore) GetApp(id string) (*model.OAuthApp, error) {
  3985  	start := timemodule.Now()
  3986  
  3987  	result, err := s.OAuthStore.GetApp(id)
  3988  
  3989  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  3990  	if s.Root.Metrics != nil {
  3991  		success := "false"
  3992  		if err == nil {
  3993  			success = "true"
  3994  		}
  3995  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetApp", success, elapsed)
  3996  	}
  3997  	return result, err
  3998  }
  3999  
  4000  func (s *TimerLayerOAuthStore) GetAppByUser(userId string, offset int, limit int) ([]*model.OAuthApp, error) {
  4001  	start := timemodule.Now()
  4002  
  4003  	result, err := s.OAuthStore.GetAppByUser(userId, offset, limit)
  4004  
  4005  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4006  	if s.Root.Metrics != nil {
  4007  		success := "false"
  4008  		if err == nil {
  4009  			success = "true"
  4010  		}
  4011  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetAppByUser", success, elapsed)
  4012  	}
  4013  	return result, err
  4014  }
  4015  
  4016  func (s *TimerLayerOAuthStore) GetApps(offset int, limit int) ([]*model.OAuthApp, error) {
  4017  	start := timemodule.Now()
  4018  
  4019  	result, err := s.OAuthStore.GetApps(offset, limit)
  4020  
  4021  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4022  	if s.Root.Metrics != nil {
  4023  		success := "false"
  4024  		if err == nil {
  4025  			success = "true"
  4026  		}
  4027  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetApps", success, elapsed)
  4028  	}
  4029  	return result, err
  4030  }
  4031  
  4032  func (s *TimerLayerOAuthStore) GetAuthData(code string) (*model.AuthData, error) {
  4033  	start := timemodule.Now()
  4034  
  4035  	result, err := s.OAuthStore.GetAuthData(code)
  4036  
  4037  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4038  	if s.Root.Metrics != nil {
  4039  		success := "false"
  4040  		if err == nil {
  4041  			success = "true"
  4042  		}
  4043  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetAuthData", success, elapsed)
  4044  	}
  4045  	return result, err
  4046  }
  4047  
  4048  func (s *TimerLayerOAuthStore) GetAuthorizedApps(userId string, offset int, limit int) ([]*model.OAuthApp, error) {
  4049  	start := timemodule.Now()
  4050  
  4051  	result, err := s.OAuthStore.GetAuthorizedApps(userId, offset, limit)
  4052  
  4053  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4054  	if s.Root.Metrics != nil {
  4055  		success := "false"
  4056  		if err == nil {
  4057  			success = "true"
  4058  		}
  4059  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetAuthorizedApps", success, elapsed)
  4060  	}
  4061  	return result, err
  4062  }
  4063  
  4064  func (s *TimerLayerOAuthStore) GetPreviousAccessData(userId string, clientId string) (*model.AccessData, error) {
  4065  	start := timemodule.Now()
  4066  
  4067  	result, err := s.OAuthStore.GetPreviousAccessData(userId, clientId)
  4068  
  4069  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4070  	if s.Root.Metrics != nil {
  4071  		success := "false"
  4072  		if err == nil {
  4073  			success = "true"
  4074  		}
  4075  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.GetPreviousAccessData", success, elapsed)
  4076  	}
  4077  	return result, err
  4078  }
  4079  
  4080  func (s *TimerLayerOAuthStore) PermanentDeleteAuthDataByUser(userId string) error {
  4081  	start := timemodule.Now()
  4082  
  4083  	err := s.OAuthStore.PermanentDeleteAuthDataByUser(userId)
  4084  
  4085  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4086  	if s.Root.Metrics != nil {
  4087  		success := "false"
  4088  		if err == nil {
  4089  			success = "true"
  4090  		}
  4091  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.PermanentDeleteAuthDataByUser", success, elapsed)
  4092  	}
  4093  	return err
  4094  }
  4095  
  4096  func (s *TimerLayerOAuthStore) RemoveAccessData(token string) error {
  4097  	start := timemodule.Now()
  4098  
  4099  	err := s.OAuthStore.RemoveAccessData(token)
  4100  
  4101  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4102  	if s.Root.Metrics != nil {
  4103  		success := "false"
  4104  		if err == nil {
  4105  			success = "true"
  4106  		}
  4107  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.RemoveAccessData", success, elapsed)
  4108  	}
  4109  	return err
  4110  }
  4111  
  4112  func (s *TimerLayerOAuthStore) RemoveAllAccessData() error {
  4113  	start := timemodule.Now()
  4114  
  4115  	err := s.OAuthStore.RemoveAllAccessData()
  4116  
  4117  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4118  	if s.Root.Metrics != nil {
  4119  		success := "false"
  4120  		if err == nil {
  4121  			success = "true"
  4122  		}
  4123  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.RemoveAllAccessData", success, elapsed)
  4124  	}
  4125  	return err
  4126  }
  4127  
  4128  func (s *TimerLayerOAuthStore) RemoveAuthData(code string) error {
  4129  	start := timemodule.Now()
  4130  
  4131  	err := s.OAuthStore.RemoveAuthData(code)
  4132  
  4133  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4134  	if s.Root.Metrics != nil {
  4135  		success := "false"
  4136  		if err == nil {
  4137  			success = "true"
  4138  		}
  4139  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.RemoveAuthData", success, elapsed)
  4140  	}
  4141  	return err
  4142  }
  4143  
  4144  func (s *TimerLayerOAuthStore) SaveAccessData(accessData *model.AccessData) (*model.AccessData, error) {
  4145  	start := timemodule.Now()
  4146  
  4147  	result, err := s.OAuthStore.SaveAccessData(accessData)
  4148  
  4149  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4150  	if s.Root.Metrics != nil {
  4151  		success := "false"
  4152  		if err == nil {
  4153  			success = "true"
  4154  		}
  4155  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.SaveAccessData", success, elapsed)
  4156  	}
  4157  	return result, err
  4158  }
  4159  
  4160  func (s *TimerLayerOAuthStore) SaveApp(app *model.OAuthApp) (*model.OAuthApp, error) {
  4161  	start := timemodule.Now()
  4162  
  4163  	result, err := s.OAuthStore.SaveApp(app)
  4164  
  4165  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4166  	if s.Root.Metrics != nil {
  4167  		success := "false"
  4168  		if err == nil {
  4169  			success = "true"
  4170  		}
  4171  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.SaveApp", success, elapsed)
  4172  	}
  4173  	return result, err
  4174  }
  4175  
  4176  func (s *TimerLayerOAuthStore) SaveAuthData(authData *model.AuthData) (*model.AuthData, error) {
  4177  	start := timemodule.Now()
  4178  
  4179  	result, err := s.OAuthStore.SaveAuthData(authData)
  4180  
  4181  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4182  	if s.Root.Metrics != nil {
  4183  		success := "false"
  4184  		if err == nil {
  4185  			success = "true"
  4186  		}
  4187  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.SaveAuthData", success, elapsed)
  4188  	}
  4189  	return result, err
  4190  }
  4191  
  4192  func (s *TimerLayerOAuthStore) UpdateAccessData(accessData *model.AccessData) (*model.AccessData, error) {
  4193  	start := timemodule.Now()
  4194  
  4195  	result, err := s.OAuthStore.UpdateAccessData(accessData)
  4196  
  4197  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4198  	if s.Root.Metrics != nil {
  4199  		success := "false"
  4200  		if err == nil {
  4201  			success = "true"
  4202  		}
  4203  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.UpdateAccessData", success, elapsed)
  4204  	}
  4205  	return result, err
  4206  }
  4207  
  4208  func (s *TimerLayerOAuthStore) UpdateApp(app *model.OAuthApp) (*model.OAuthApp, error) {
  4209  	start := timemodule.Now()
  4210  
  4211  	result, err := s.OAuthStore.UpdateApp(app)
  4212  
  4213  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4214  	if s.Root.Metrics != nil {
  4215  		success := "false"
  4216  		if err == nil {
  4217  			success = "true"
  4218  		}
  4219  		s.Root.Metrics.ObserveStoreMethodDuration("OAuthStore.UpdateApp", success, elapsed)
  4220  	}
  4221  	return result, err
  4222  }
  4223  
  4224  func (s *TimerLayerPluginStore) CompareAndDelete(keyVal *model.PluginKeyValue, oldValue []byte) (bool, error) {
  4225  	start := timemodule.Now()
  4226  
  4227  	result, err := s.PluginStore.CompareAndDelete(keyVal, oldValue)
  4228  
  4229  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4230  	if s.Root.Metrics != nil {
  4231  		success := "false"
  4232  		if err == nil {
  4233  			success = "true"
  4234  		}
  4235  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.CompareAndDelete", success, elapsed)
  4236  	}
  4237  	return result, err
  4238  }
  4239  
  4240  func (s *TimerLayerPluginStore) CompareAndSet(keyVal *model.PluginKeyValue, oldValue []byte) (bool, error) {
  4241  	start := timemodule.Now()
  4242  
  4243  	result, err := s.PluginStore.CompareAndSet(keyVal, oldValue)
  4244  
  4245  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4246  	if s.Root.Metrics != nil {
  4247  		success := "false"
  4248  		if err == nil {
  4249  			success = "true"
  4250  		}
  4251  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.CompareAndSet", success, elapsed)
  4252  	}
  4253  	return result, err
  4254  }
  4255  
  4256  func (s *TimerLayerPluginStore) Delete(pluginId string, key string) error {
  4257  	start := timemodule.Now()
  4258  
  4259  	err := s.PluginStore.Delete(pluginId, key)
  4260  
  4261  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4262  	if s.Root.Metrics != nil {
  4263  		success := "false"
  4264  		if err == nil {
  4265  			success = "true"
  4266  		}
  4267  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.Delete", success, elapsed)
  4268  	}
  4269  	return err
  4270  }
  4271  
  4272  func (s *TimerLayerPluginStore) DeleteAllExpired() error {
  4273  	start := timemodule.Now()
  4274  
  4275  	err := s.PluginStore.DeleteAllExpired()
  4276  
  4277  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4278  	if s.Root.Metrics != nil {
  4279  		success := "false"
  4280  		if err == nil {
  4281  			success = "true"
  4282  		}
  4283  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.DeleteAllExpired", success, elapsed)
  4284  	}
  4285  	return err
  4286  }
  4287  
  4288  func (s *TimerLayerPluginStore) DeleteAllForPlugin(PluginId string) error {
  4289  	start := timemodule.Now()
  4290  
  4291  	err := s.PluginStore.DeleteAllForPlugin(PluginId)
  4292  
  4293  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4294  	if s.Root.Metrics != nil {
  4295  		success := "false"
  4296  		if err == nil {
  4297  			success = "true"
  4298  		}
  4299  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.DeleteAllForPlugin", success, elapsed)
  4300  	}
  4301  	return err
  4302  }
  4303  
  4304  func (s *TimerLayerPluginStore) Get(pluginId string, key string) (*model.PluginKeyValue, error) {
  4305  	start := timemodule.Now()
  4306  
  4307  	result, err := s.PluginStore.Get(pluginId, key)
  4308  
  4309  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4310  	if s.Root.Metrics != nil {
  4311  		success := "false"
  4312  		if err == nil {
  4313  			success = "true"
  4314  		}
  4315  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.Get", success, elapsed)
  4316  	}
  4317  	return result, err
  4318  }
  4319  
  4320  func (s *TimerLayerPluginStore) List(pluginId string, page int, perPage int) ([]string, error) {
  4321  	start := timemodule.Now()
  4322  
  4323  	result, err := s.PluginStore.List(pluginId, page, perPage)
  4324  
  4325  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4326  	if s.Root.Metrics != nil {
  4327  		success := "false"
  4328  		if err == nil {
  4329  			success = "true"
  4330  		}
  4331  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.List", success, elapsed)
  4332  	}
  4333  	return result, err
  4334  }
  4335  
  4336  func (s *TimerLayerPluginStore) SaveOrUpdate(keyVal *model.PluginKeyValue) (*model.PluginKeyValue, error) {
  4337  	start := timemodule.Now()
  4338  
  4339  	result, err := s.PluginStore.SaveOrUpdate(keyVal)
  4340  
  4341  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4342  	if s.Root.Metrics != nil {
  4343  		success := "false"
  4344  		if err == nil {
  4345  			success = "true"
  4346  		}
  4347  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.SaveOrUpdate", success, elapsed)
  4348  	}
  4349  	return result, err
  4350  }
  4351  
  4352  func (s *TimerLayerPluginStore) SetWithOptions(pluginId string, key string, value []byte, options model.PluginKVSetOptions) (bool, error) {
  4353  	start := timemodule.Now()
  4354  
  4355  	result, err := s.PluginStore.SetWithOptions(pluginId, key, value, options)
  4356  
  4357  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4358  	if s.Root.Metrics != nil {
  4359  		success := "false"
  4360  		if err == nil {
  4361  			success = "true"
  4362  		}
  4363  		s.Root.Metrics.ObserveStoreMethodDuration("PluginStore.SetWithOptions", success, elapsed)
  4364  	}
  4365  	return result, err
  4366  }
  4367  
  4368  func (s *TimerLayerPostStore) AnalyticsPostCount(teamId string, mustHaveFile bool, mustHaveHashtag bool) (int64, error) {
  4369  	start := timemodule.Now()
  4370  
  4371  	result, err := s.PostStore.AnalyticsPostCount(teamId, mustHaveFile, mustHaveHashtag)
  4372  
  4373  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4374  	if s.Root.Metrics != nil {
  4375  		success := "false"
  4376  		if err == nil {
  4377  			success = "true"
  4378  		}
  4379  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.AnalyticsPostCount", success, elapsed)
  4380  	}
  4381  	return result, err
  4382  }
  4383  
  4384  func (s *TimerLayerPostStore) AnalyticsPostCountsByDay(options *model.AnalyticsPostCountsOptions) (model.AnalyticsRows, error) {
  4385  	start := timemodule.Now()
  4386  
  4387  	result, err := s.PostStore.AnalyticsPostCountsByDay(options)
  4388  
  4389  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4390  	if s.Root.Metrics != nil {
  4391  		success := "false"
  4392  		if err == nil {
  4393  			success = "true"
  4394  		}
  4395  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.AnalyticsPostCountsByDay", success, elapsed)
  4396  	}
  4397  	return result, err
  4398  }
  4399  
  4400  func (s *TimerLayerPostStore) AnalyticsUserCountsWithPostsByDay(teamId string) (model.AnalyticsRows, error) {
  4401  	start := timemodule.Now()
  4402  
  4403  	result, err := s.PostStore.AnalyticsUserCountsWithPostsByDay(teamId)
  4404  
  4405  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4406  	if s.Root.Metrics != nil {
  4407  		success := "false"
  4408  		if err == nil {
  4409  			success = "true"
  4410  		}
  4411  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.AnalyticsUserCountsWithPostsByDay", success, elapsed)
  4412  	}
  4413  	return result, err
  4414  }
  4415  
  4416  func (s *TimerLayerPostStore) ClearCaches() {
  4417  	start := timemodule.Now()
  4418  
  4419  	s.PostStore.ClearCaches()
  4420  
  4421  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4422  	if s.Root.Metrics != nil {
  4423  		success := "false"
  4424  		if true {
  4425  			success = "true"
  4426  		}
  4427  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.ClearCaches", success, elapsed)
  4428  	}
  4429  }
  4430  
  4431  func (s *TimerLayerPostStore) Delete(postId string, time int64, deleteByID string) error {
  4432  	start := timemodule.Now()
  4433  
  4434  	err := s.PostStore.Delete(postId, time, deleteByID)
  4435  
  4436  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4437  	if s.Root.Metrics != nil {
  4438  		success := "false"
  4439  		if err == nil {
  4440  			success = "true"
  4441  		}
  4442  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.Delete", success, elapsed)
  4443  	}
  4444  	return err
  4445  }
  4446  
  4447  func (s *TimerLayerPostStore) Get(id string, skipFetchThreads bool, collapsedThreads bool, collapsedThreadsExtended bool) (*model.PostList, error) {
  4448  	start := timemodule.Now()
  4449  
  4450  	result, err := s.PostStore.Get(id, skipFetchThreads, collapsedThreads, collapsedThreadsExtended)
  4451  
  4452  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4453  	if s.Root.Metrics != nil {
  4454  		success := "false"
  4455  		if err == nil {
  4456  			success = "true"
  4457  		}
  4458  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.Get", success, elapsed)
  4459  	}
  4460  	return result, err
  4461  }
  4462  
  4463  func (s *TimerLayerPostStore) GetDirectPostParentsForExportAfter(limit int, afterId string) ([]*model.DirectPostForExport, error) {
  4464  	start := timemodule.Now()
  4465  
  4466  	result, err := s.PostStore.GetDirectPostParentsForExportAfter(limit, afterId)
  4467  
  4468  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4469  	if s.Root.Metrics != nil {
  4470  		success := "false"
  4471  		if err == nil {
  4472  			success = "true"
  4473  		}
  4474  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetDirectPostParentsForExportAfter", success, elapsed)
  4475  	}
  4476  	return result, err
  4477  }
  4478  
  4479  func (s *TimerLayerPostStore) GetEtag(channelId string, allowFromCache bool, collapsedThreads bool) string {
  4480  	start := timemodule.Now()
  4481  
  4482  	result := s.PostStore.GetEtag(channelId, allowFromCache, collapsedThreads)
  4483  
  4484  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4485  	if s.Root.Metrics != nil {
  4486  		success := "false"
  4487  		if true {
  4488  			success = "true"
  4489  		}
  4490  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetEtag", success, elapsed)
  4491  	}
  4492  	return result
  4493  }
  4494  
  4495  func (s *TimerLayerPostStore) GetFlaggedPosts(userId string, offset int, limit int) (*model.PostList, error) {
  4496  	start := timemodule.Now()
  4497  
  4498  	result, err := s.PostStore.GetFlaggedPosts(userId, offset, limit)
  4499  
  4500  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4501  	if s.Root.Metrics != nil {
  4502  		success := "false"
  4503  		if err == nil {
  4504  			success = "true"
  4505  		}
  4506  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetFlaggedPosts", success, elapsed)
  4507  	}
  4508  	return result, err
  4509  }
  4510  
  4511  func (s *TimerLayerPostStore) GetFlaggedPostsForChannel(userId string, channelId string, offset int, limit int) (*model.PostList, error) {
  4512  	start := timemodule.Now()
  4513  
  4514  	result, err := s.PostStore.GetFlaggedPostsForChannel(userId, channelId, offset, limit)
  4515  
  4516  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4517  	if s.Root.Metrics != nil {
  4518  		success := "false"
  4519  		if err == nil {
  4520  			success = "true"
  4521  		}
  4522  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetFlaggedPostsForChannel", success, elapsed)
  4523  	}
  4524  	return result, err
  4525  }
  4526  
  4527  func (s *TimerLayerPostStore) GetFlaggedPostsForTeam(userId string, teamId string, offset int, limit int) (*model.PostList, error) {
  4528  	start := timemodule.Now()
  4529  
  4530  	result, err := s.PostStore.GetFlaggedPostsForTeam(userId, teamId, offset, limit)
  4531  
  4532  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4533  	if s.Root.Metrics != nil {
  4534  		success := "false"
  4535  		if err == nil {
  4536  			success = "true"
  4537  		}
  4538  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetFlaggedPostsForTeam", success, elapsed)
  4539  	}
  4540  	return result, err
  4541  }
  4542  
  4543  func (s *TimerLayerPostStore) GetMaxPostSize() int {
  4544  	start := timemodule.Now()
  4545  
  4546  	result := s.PostStore.GetMaxPostSize()
  4547  
  4548  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4549  	if s.Root.Metrics != nil {
  4550  		success := "false"
  4551  		if true {
  4552  			success = "true"
  4553  		}
  4554  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetMaxPostSize", success, elapsed)
  4555  	}
  4556  	return result
  4557  }
  4558  
  4559  func (s *TimerLayerPostStore) GetOldest() (*model.Post, error) {
  4560  	start := timemodule.Now()
  4561  
  4562  	result, err := s.PostStore.GetOldest()
  4563  
  4564  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4565  	if s.Root.Metrics != nil {
  4566  		success := "false"
  4567  		if err == nil {
  4568  			success = "true"
  4569  		}
  4570  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetOldest", success, elapsed)
  4571  	}
  4572  	return result, err
  4573  }
  4574  
  4575  func (s *TimerLayerPostStore) GetOldestEntityCreationTime() (int64, error) {
  4576  	start := timemodule.Now()
  4577  
  4578  	result, err := s.PostStore.GetOldestEntityCreationTime()
  4579  
  4580  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4581  	if s.Root.Metrics != nil {
  4582  		success := "false"
  4583  		if err == nil {
  4584  			success = "true"
  4585  		}
  4586  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetOldestEntityCreationTime", success, elapsed)
  4587  	}
  4588  	return result, err
  4589  }
  4590  
  4591  func (s *TimerLayerPostStore) GetParentsForExportAfter(limit int, afterId string) ([]*model.PostForExport, error) {
  4592  	start := timemodule.Now()
  4593  
  4594  	result, err := s.PostStore.GetParentsForExportAfter(limit, afterId)
  4595  
  4596  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4597  	if s.Root.Metrics != nil {
  4598  		success := "false"
  4599  		if err == nil {
  4600  			success = "true"
  4601  		}
  4602  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetParentsForExportAfter", success, elapsed)
  4603  	}
  4604  	return result, err
  4605  }
  4606  
  4607  func (s *TimerLayerPostStore) GetPostAfterTime(channelId string, time int64) (*model.Post, error) {
  4608  	start := timemodule.Now()
  4609  
  4610  	result, err := s.PostStore.GetPostAfterTime(channelId, time)
  4611  
  4612  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4613  	if s.Root.Metrics != nil {
  4614  		success := "false"
  4615  		if err == nil {
  4616  			success = "true"
  4617  		}
  4618  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostAfterTime", success, elapsed)
  4619  	}
  4620  	return result, err
  4621  }
  4622  
  4623  func (s *TimerLayerPostStore) GetPostIdAfterTime(channelId string, time int64) (string, error) {
  4624  	start := timemodule.Now()
  4625  
  4626  	result, err := s.PostStore.GetPostIdAfterTime(channelId, time)
  4627  
  4628  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4629  	if s.Root.Metrics != nil {
  4630  		success := "false"
  4631  		if err == nil {
  4632  			success = "true"
  4633  		}
  4634  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostIdAfterTime", success, elapsed)
  4635  	}
  4636  	return result, err
  4637  }
  4638  
  4639  func (s *TimerLayerPostStore) GetPostIdBeforeTime(channelId string, time int64) (string, error) {
  4640  	start := timemodule.Now()
  4641  
  4642  	result, err := s.PostStore.GetPostIdBeforeTime(channelId, time)
  4643  
  4644  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4645  	if s.Root.Metrics != nil {
  4646  		success := "false"
  4647  		if err == nil {
  4648  			success = "true"
  4649  		}
  4650  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostIdBeforeTime", success, elapsed)
  4651  	}
  4652  	return result, err
  4653  }
  4654  
  4655  func (s *TimerLayerPostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool) (*model.PostList, error) {
  4656  	start := timemodule.Now()
  4657  
  4658  	result, err := s.PostStore.GetPosts(options, allowFromCache)
  4659  
  4660  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4661  	if s.Root.Metrics != nil {
  4662  		success := "false"
  4663  		if err == nil {
  4664  			success = "true"
  4665  		}
  4666  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPosts", success, elapsed)
  4667  	}
  4668  	return result, err
  4669  }
  4670  
  4671  func (s *TimerLayerPostStore) GetPostsAfter(options model.GetPostsOptions) (*model.PostList, error) {
  4672  	start := timemodule.Now()
  4673  
  4674  	result, err := s.PostStore.GetPostsAfter(options)
  4675  
  4676  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4677  	if s.Root.Metrics != nil {
  4678  		success := "false"
  4679  		if err == nil {
  4680  			success = "true"
  4681  		}
  4682  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostsAfter", success, elapsed)
  4683  	}
  4684  	return result, err
  4685  }
  4686  
  4687  func (s *TimerLayerPostStore) GetPostsBatchForIndexing(startTime int64, endTime int64, limit int) ([]*model.PostForIndexing, error) {
  4688  	start := timemodule.Now()
  4689  
  4690  	result, err := s.PostStore.GetPostsBatchForIndexing(startTime, endTime, limit)
  4691  
  4692  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4693  	if s.Root.Metrics != nil {
  4694  		success := "false"
  4695  		if err == nil {
  4696  			success = "true"
  4697  		}
  4698  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostsBatchForIndexing", success, elapsed)
  4699  	}
  4700  	return result, err
  4701  }
  4702  
  4703  func (s *TimerLayerPostStore) GetPostsBefore(options model.GetPostsOptions) (*model.PostList, error) {
  4704  	start := timemodule.Now()
  4705  
  4706  	result, err := s.PostStore.GetPostsBefore(options)
  4707  
  4708  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4709  	if s.Root.Metrics != nil {
  4710  		success := "false"
  4711  		if err == nil {
  4712  			success = "true"
  4713  		}
  4714  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostsBefore", success, elapsed)
  4715  	}
  4716  	return result, err
  4717  }
  4718  
  4719  func (s *TimerLayerPostStore) GetPostsByIds(postIds []string) ([]*model.Post, error) {
  4720  	start := timemodule.Now()
  4721  
  4722  	result, err := s.PostStore.GetPostsByIds(postIds)
  4723  
  4724  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4725  	if s.Root.Metrics != nil {
  4726  		success := "false"
  4727  		if err == nil {
  4728  			success = "true"
  4729  		}
  4730  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostsByIds", success, elapsed)
  4731  	}
  4732  	return result, err
  4733  }
  4734  
  4735  func (s *TimerLayerPostStore) GetPostsCreatedAt(channelId string, time int64) ([]*model.Post, error) {
  4736  	start := timemodule.Now()
  4737  
  4738  	result, err := s.PostStore.GetPostsCreatedAt(channelId, time)
  4739  
  4740  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4741  	if s.Root.Metrics != nil {
  4742  		success := "false"
  4743  		if err == nil {
  4744  			success = "true"
  4745  		}
  4746  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostsCreatedAt", success, elapsed)
  4747  	}
  4748  	return result, err
  4749  }
  4750  
  4751  func (s *TimerLayerPostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool) (*model.PostList, error) {
  4752  	start := timemodule.Now()
  4753  
  4754  	result, err := s.PostStore.GetPostsSince(options, allowFromCache)
  4755  
  4756  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4757  	if s.Root.Metrics != nil {
  4758  		success := "false"
  4759  		if err == nil {
  4760  			success = "true"
  4761  		}
  4762  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetPostsSince", success, elapsed)
  4763  	}
  4764  	return result, err
  4765  }
  4766  
  4767  func (s *TimerLayerPostStore) GetRepliesForExport(parentId string) ([]*model.ReplyForExport, error) {
  4768  	start := timemodule.Now()
  4769  
  4770  	result, err := s.PostStore.GetRepliesForExport(parentId)
  4771  
  4772  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4773  	if s.Root.Metrics != nil {
  4774  		success := "false"
  4775  		if err == nil {
  4776  			success = "true"
  4777  		}
  4778  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetRepliesForExport", success, elapsed)
  4779  	}
  4780  	return result, err
  4781  }
  4782  
  4783  func (s *TimerLayerPostStore) GetSingle(id string) (*model.Post, error) {
  4784  	start := timemodule.Now()
  4785  
  4786  	result, err := s.PostStore.GetSingle(id)
  4787  
  4788  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4789  	if s.Root.Metrics != nil {
  4790  		success := "false"
  4791  		if err == nil {
  4792  			success = "true"
  4793  		}
  4794  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.GetSingle", success, elapsed)
  4795  	}
  4796  	return result, err
  4797  }
  4798  
  4799  func (s *TimerLayerPostStore) InvalidateLastPostTimeCache(channelId string) {
  4800  	start := timemodule.Now()
  4801  
  4802  	s.PostStore.InvalidateLastPostTimeCache(channelId)
  4803  
  4804  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4805  	if s.Root.Metrics != nil {
  4806  		success := "false"
  4807  		if true {
  4808  			success = "true"
  4809  		}
  4810  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.InvalidateLastPostTimeCache", success, elapsed)
  4811  	}
  4812  }
  4813  
  4814  func (s *TimerLayerPostStore) Overwrite(post *model.Post) (*model.Post, error) {
  4815  	start := timemodule.Now()
  4816  
  4817  	result, err := s.PostStore.Overwrite(post)
  4818  
  4819  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4820  	if s.Root.Metrics != nil {
  4821  		success := "false"
  4822  		if err == nil {
  4823  			success = "true"
  4824  		}
  4825  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.Overwrite", success, elapsed)
  4826  	}
  4827  	return result, err
  4828  }
  4829  
  4830  func (s *TimerLayerPostStore) OverwriteMultiple(posts []*model.Post) ([]*model.Post, int, error) {
  4831  	start := timemodule.Now()
  4832  
  4833  	result, resultVar1, err := s.PostStore.OverwriteMultiple(posts)
  4834  
  4835  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4836  	if s.Root.Metrics != nil {
  4837  		success := "false"
  4838  		if err == nil {
  4839  			success = "true"
  4840  		}
  4841  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.OverwriteMultiple", success, elapsed)
  4842  	}
  4843  	return result, resultVar1, err
  4844  }
  4845  
  4846  func (s *TimerLayerPostStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, error) {
  4847  	start := timemodule.Now()
  4848  
  4849  	result, err := s.PostStore.PermanentDeleteBatch(endTime, limit)
  4850  
  4851  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4852  	if s.Root.Metrics != nil {
  4853  		success := "false"
  4854  		if err == nil {
  4855  			success = "true"
  4856  		}
  4857  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.PermanentDeleteBatch", success, elapsed)
  4858  	}
  4859  	return result, err
  4860  }
  4861  
  4862  func (s *TimerLayerPostStore) PermanentDeleteByChannel(channelId string) error {
  4863  	start := timemodule.Now()
  4864  
  4865  	err := s.PostStore.PermanentDeleteByChannel(channelId)
  4866  
  4867  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4868  	if s.Root.Metrics != nil {
  4869  		success := "false"
  4870  		if err == nil {
  4871  			success = "true"
  4872  		}
  4873  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.PermanentDeleteByChannel", success, elapsed)
  4874  	}
  4875  	return err
  4876  }
  4877  
  4878  func (s *TimerLayerPostStore) PermanentDeleteByUser(userId string) error {
  4879  	start := timemodule.Now()
  4880  
  4881  	err := s.PostStore.PermanentDeleteByUser(userId)
  4882  
  4883  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4884  	if s.Root.Metrics != nil {
  4885  		success := "false"
  4886  		if err == nil {
  4887  			success = "true"
  4888  		}
  4889  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.PermanentDeleteByUser", success, elapsed)
  4890  	}
  4891  	return err
  4892  }
  4893  
  4894  func (s *TimerLayerPostStore) Save(post *model.Post) (*model.Post, error) {
  4895  	start := timemodule.Now()
  4896  
  4897  	result, err := s.PostStore.Save(post)
  4898  
  4899  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4900  	if s.Root.Metrics != nil {
  4901  		success := "false"
  4902  		if err == nil {
  4903  			success = "true"
  4904  		}
  4905  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.Save", success, elapsed)
  4906  	}
  4907  	return result, err
  4908  }
  4909  
  4910  func (s *TimerLayerPostStore) SaveMultiple(posts []*model.Post) ([]*model.Post, int, error) {
  4911  	start := timemodule.Now()
  4912  
  4913  	result, resultVar1, err := s.PostStore.SaveMultiple(posts)
  4914  
  4915  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4916  	if s.Root.Metrics != nil {
  4917  		success := "false"
  4918  		if err == nil {
  4919  			success = "true"
  4920  		}
  4921  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.SaveMultiple", success, elapsed)
  4922  	}
  4923  	return result, resultVar1, err
  4924  }
  4925  
  4926  func (s *TimerLayerPostStore) Search(teamId string, userId string, params *model.SearchParams) (*model.PostList, error) {
  4927  	start := timemodule.Now()
  4928  
  4929  	result, err := s.PostStore.Search(teamId, userId, params)
  4930  
  4931  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4932  	if s.Root.Metrics != nil {
  4933  		success := "false"
  4934  		if err == nil {
  4935  			success = "true"
  4936  		}
  4937  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.Search", success, elapsed)
  4938  	}
  4939  	return result, err
  4940  }
  4941  
  4942  func (s *TimerLayerPostStore) SearchPostsInTeamForUser(paramsList []*model.SearchParams, userId string, teamId string, page int, perPage int) (*model.PostSearchResults, error) {
  4943  	start := timemodule.Now()
  4944  
  4945  	result, err := s.PostStore.SearchPostsInTeamForUser(paramsList, userId, teamId, page, perPage)
  4946  
  4947  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4948  	if s.Root.Metrics != nil {
  4949  		success := "false"
  4950  		if err == nil {
  4951  			success = "true"
  4952  		}
  4953  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.SearchPostsInTeamForUser", success, elapsed)
  4954  	}
  4955  	return result, err
  4956  }
  4957  
  4958  func (s *TimerLayerPostStore) Update(newPost *model.Post, oldPost *model.Post) (*model.Post, error) {
  4959  	start := timemodule.Now()
  4960  
  4961  	result, err := s.PostStore.Update(newPost, oldPost)
  4962  
  4963  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4964  	if s.Root.Metrics != nil {
  4965  		success := "false"
  4966  		if err == nil {
  4967  			success = "true"
  4968  		}
  4969  		s.Root.Metrics.ObserveStoreMethodDuration("PostStore.Update", success, elapsed)
  4970  	}
  4971  	return result, err
  4972  }
  4973  
  4974  func (s *TimerLayerPreferenceStore) CleanupFlagsBatch(limit int64) (int64, error) {
  4975  	start := timemodule.Now()
  4976  
  4977  	result, err := s.PreferenceStore.CleanupFlagsBatch(limit)
  4978  
  4979  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4980  	if s.Root.Metrics != nil {
  4981  		success := "false"
  4982  		if err == nil {
  4983  			success = "true"
  4984  		}
  4985  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.CleanupFlagsBatch", success, elapsed)
  4986  	}
  4987  	return result, err
  4988  }
  4989  
  4990  func (s *TimerLayerPreferenceStore) Delete(userId string, category string, name string) error {
  4991  	start := timemodule.Now()
  4992  
  4993  	err := s.PreferenceStore.Delete(userId, category, name)
  4994  
  4995  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  4996  	if s.Root.Metrics != nil {
  4997  		success := "false"
  4998  		if err == nil {
  4999  			success = "true"
  5000  		}
  5001  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.Delete", success, elapsed)
  5002  	}
  5003  	return err
  5004  }
  5005  
  5006  func (s *TimerLayerPreferenceStore) DeleteCategory(userId string, category string) error {
  5007  	start := timemodule.Now()
  5008  
  5009  	err := s.PreferenceStore.DeleteCategory(userId, category)
  5010  
  5011  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5012  	if s.Root.Metrics != nil {
  5013  		success := "false"
  5014  		if err == nil {
  5015  			success = "true"
  5016  		}
  5017  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.DeleteCategory", success, elapsed)
  5018  	}
  5019  	return err
  5020  }
  5021  
  5022  func (s *TimerLayerPreferenceStore) DeleteCategoryAndName(category string, name string) error {
  5023  	start := timemodule.Now()
  5024  
  5025  	err := s.PreferenceStore.DeleteCategoryAndName(category, name)
  5026  
  5027  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5028  	if s.Root.Metrics != nil {
  5029  		success := "false"
  5030  		if err == nil {
  5031  			success = "true"
  5032  		}
  5033  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.DeleteCategoryAndName", success, elapsed)
  5034  	}
  5035  	return err
  5036  }
  5037  
  5038  func (s *TimerLayerPreferenceStore) Get(userId string, category string, name string) (*model.Preference, error) {
  5039  	start := timemodule.Now()
  5040  
  5041  	result, err := s.PreferenceStore.Get(userId, category, name)
  5042  
  5043  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5044  	if s.Root.Metrics != nil {
  5045  		success := "false"
  5046  		if err == nil {
  5047  			success = "true"
  5048  		}
  5049  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.Get", success, elapsed)
  5050  	}
  5051  	return result, err
  5052  }
  5053  
  5054  func (s *TimerLayerPreferenceStore) GetAll(userId string) (model.Preferences, error) {
  5055  	start := timemodule.Now()
  5056  
  5057  	result, err := s.PreferenceStore.GetAll(userId)
  5058  
  5059  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5060  	if s.Root.Metrics != nil {
  5061  		success := "false"
  5062  		if err == nil {
  5063  			success = "true"
  5064  		}
  5065  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.GetAll", success, elapsed)
  5066  	}
  5067  	return result, err
  5068  }
  5069  
  5070  func (s *TimerLayerPreferenceStore) GetCategory(userId string, category string) (model.Preferences, error) {
  5071  	start := timemodule.Now()
  5072  
  5073  	result, err := s.PreferenceStore.GetCategory(userId, category)
  5074  
  5075  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5076  	if s.Root.Metrics != nil {
  5077  		success := "false"
  5078  		if err == nil {
  5079  			success = "true"
  5080  		}
  5081  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.GetCategory", success, elapsed)
  5082  	}
  5083  	return result, err
  5084  }
  5085  
  5086  func (s *TimerLayerPreferenceStore) PermanentDeleteByUser(userId string) error {
  5087  	start := timemodule.Now()
  5088  
  5089  	err := s.PreferenceStore.PermanentDeleteByUser(userId)
  5090  
  5091  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5092  	if s.Root.Metrics != nil {
  5093  		success := "false"
  5094  		if err == nil {
  5095  			success = "true"
  5096  		}
  5097  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.PermanentDeleteByUser", success, elapsed)
  5098  	}
  5099  	return err
  5100  }
  5101  
  5102  func (s *TimerLayerPreferenceStore) Save(preferences *model.Preferences) error {
  5103  	start := timemodule.Now()
  5104  
  5105  	err := s.PreferenceStore.Save(preferences)
  5106  
  5107  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5108  	if s.Root.Metrics != nil {
  5109  		success := "false"
  5110  		if err == nil {
  5111  			success = "true"
  5112  		}
  5113  		s.Root.Metrics.ObserveStoreMethodDuration("PreferenceStore.Save", success, elapsed)
  5114  	}
  5115  	return err
  5116  }
  5117  
  5118  func (s *TimerLayerProductNoticesStore) Clear(notices []string) error {
  5119  	start := timemodule.Now()
  5120  
  5121  	err := s.ProductNoticesStore.Clear(notices)
  5122  
  5123  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5124  	if s.Root.Metrics != nil {
  5125  		success := "false"
  5126  		if err == nil {
  5127  			success = "true"
  5128  		}
  5129  		s.Root.Metrics.ObserveStoreMethodDuration("ProductNoticesStore.Clear", success, elapsed)
  5130  	}
  5131  	return err
  5132  }
  5133  
  5134  func (s *TimerLayerProductNoticesStore) ClearOldNotices(currentNotices *model.ProductNotices) error {
  5135  	start := timemodule.Now()
  5136  
  5137  	err := s.ProductNoticesStore.ClearOldNotices(currentNotices)
  5138  
  5139  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5140  	if s.Root.Metrics != nil {
  5141  		success := "false"
  5142  		if err == nil {
  5143  			success = "true"
  5144  		}
  5145  		s.Root.Metrics.ObserveStoreMethodDuration("ProductNoticesStore.ClearOldNotices", success, elapsed)
  5146  	}
  5147  	return err
  5148  }
  5149  
  5150  func (s *TimerLayerProductNoticesStore) GetViews(userId string) ([]model.ProductNoticeViewState, error) {
  5151  	start := timemodule.Now()
  5152  
  5153  	result, err := s.ProductNoticesStore.GetViews(userId)
  5154  
  5155  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5156  	if s.Root.Metrics != nil {
  5157  		success := "false"
  5158  		if err == nil {
  5159  			success = "true"
  5160  		}
  5161  		s.Root.Metrics.ObserveStoreMethodDuration("ProductNoticesStore.GetViews", success, elapsed)
  5162  	}
  5163  	return result, err
  5164  }
  5165  
  5166  func (s *TimerLayerProductNoticesStore) View(userId string, notices []string) error {
  5167  	start := timemodule.Now()
  5168  
  5169  	err := s.ProductNoticesStore.View(userId, notices)
  5170  
  5171  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5172  	if s.Root.Metrics != nil {
  5173  		success := "false"
  5174  		if err == nil {
  5175  			success = "true"
  5176  		}
  5177  		s.Root.Metrics.ObserveStoreMethodDuration("ProductNoticesStore.View", success, elapsed)
  5178  	}
  5179  	return err
  5180  }
  5181  
  5182  func (s *TimerLayerReactionStore) BulkGetForPosts(postIds []string) ([]*model.Reaction, error) {
  5183  	start := timemodule.Now()
  5184  
  5185  	result, err := s.ReactionStore.BulkGetForPosts(postIds)
  5186  
  5187  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5188  	if s.Root.Metrics != nil {
  5189  		success := "false"
  5190  		if err == nil {
  5191  			success = "true"
  5192  		}
  5193  		s.Root.Metrics.ObserveStoreMethodDuration("ReactionStore.BulkGetForPosts", success, elapsed)
  5194  	}
  5195  	return result, err
  5196  }
  5197  
  5198  func (s *TimerLayerReactionStore) Delete(reaction *model.Reaction) (*model.Reaction, error) {
  5199  	start := timemodule.Now()
  5200  
  5201  	result, err := s.ReactionStore.Delete(reaction)
  5202  
  5203  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5204  	if s.Root.Metrics != nil {
  5205  		success := "false"
  5206  		if err == nil {
  5207  			success = "true"
  5208  		}
  5209  		s.Root.Metrics.ObserveStoreMethodDuration("ReactionStore.Delete", success, elapsed)
  5210  	}
  5211  	return result, err
  5212  }
  5213  
  5214  func (s *TimerLayerReactionStore) DeleteAllWithEmojiName(emojiName string) error {
  5215  	start := timemodule.Now()
  5216  
  5217  	err := s.ReactionStore.DeleteAllWithEmojiName(emojiName)
  5218  
  5219  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5220  	if s.Root.Metrics != nil {
  5221  		success := "false"
  5222  		if err == nil {
  5223  			success = "true"
  5224  		}
  5225  		s.Root.Metrics.ObserveStoreMethodDuration("ReactionStore.DeleteAllWithEmojiName", success, elapsed)
  5226  	}
  5227  	return err
  5228  }
  5229  
  5230  func (s *TimerLayerReactionStore) GetForPost(postId string, allowFromCache bool) ([]*model.Reaction, error) {
  5231  	start := timemodule.Now()
  5232  
  5233  	result, err := s.ReactionStore.GetForPost(postId, allowFromCache)
  5234  
  5235  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5236  	if s.Root.Metrics != nil {
  5237  		success := "false"
  5238  		if err == nil {
  5239  			success = "true"
  5240  		}
  5241  		s.Root.Metrics.ObserveStoreMethodDuration("ReactionStore.GetForPost", success, elapsed)
  5242  	}
  5243  	return result, err
  5244  }
  5245  
  5246  func (s *TimerLayerReactionStore) PermanentDeleteBatch(endTime int64, limit int64) (int64, error) {
  5247  	start := timemodule.Now()
  5248  
  5249  	result, err := s.ReactionStore.PermanentDeleteBatch(endTime, limit)
  5250  
  5251  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5252  	if s.Root.Metrics != nil {
  5253  		success := "false"
  5254  		if err == nil {
  5255  			success = "true"
  5256  		}
  5257  		s.Root.Metrics.ObserveStoreMethodDuration("ReactionStore.PermanentDeleteBatch", success, elapsed)
  5258  	}
  5259  	return result, err
  5260  }
  5261  
  5262  func (s *TimerLayerReactionStore) Save(reaction *model.Reaction) (*model.Reaction, error) {
  5263  	start := timemodule.Now()
  5264  
  5265  	result, err := s.ReactionStore.Save(reaction)
  5266  
  5267  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5268  	if s.Root.Metrics != nil {
  5269  		success := "false"
  5270  		if err == nil {
  5271  			success = "true"
  5272  		}
  5273  		s.Root.Metrics.ObserveStoreMethodDuration("ReactionStore.Save", success, elapsed)
  5274  	}
  5275  	return result, err
  5276  }
  5277  
  5278  func (s *TimerLayerRoleStore) AllChannelSchemeRoles() ([]*model.Role, error) {
  5279  	start := timemodule.Now()
  5280  
  5281  	result, err := s.RoleStore.AllChannelSchemeRoles()
  5282  
  5283  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5284  	if s.Root.Metrics != nil {
  5285  		success := "false"
  5286  		if err == nil {
  5287  			success = "true"
  5288  		}
  5289  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.AllChannelSchemeRoles", success, elapsed)
  5290  	}
  5291  	return result, err
  5292  }
  5293  
  5294  func (s *TimerLayerRoleStore) ChannelHigherScopedPermissions(roleNames []string) (map[string]*model.RolePermissions, error) {
  5295  	start := timemodule.Now()
  5296  
  5297  	result, err := s.RoleStore.ChannelHigherScopedPermissions(roleNames)
  5298  
  5299  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5300  	if s.Root.Metrics != nil {
  5301  		success := "false"
  5302  		if err == nil {
  5303  			success = "true"
  5304  		}
  5305  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.ChannelHigherScopedPermissions", success, elapsed)
  5306  	}
  5307  	return result, err
  5308  }
  5309  
  5310  func (s *TimerLayerRoleStore) ChannelRolesUnderTeamRole(roleName string) ([]*model.Role, error) {
  5311  	start := timemodule.Now()
  5312  
  5313  	result, err := s.RoleStore.ChannelRolesUnderTeamRole(roleName)
  5314  
  5315  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5316  	if s.Root.Metrics != nil {
  5317  		success := "false"
  5318  		if err == nil {
  5319  			success = "true"
  5320  		}
  5321  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.ChannelRolesUnderTeamRole", success, elapsed)
  5322  	}
  5323  	return result, err
  5324  }
  5325  
  5326  func (s *TimerLayerRoleStore) Delete(roleId string) (*model.Role, error) {
  5327  	start := timemodule.Now()
  5328  
  5329  	result, err := s.RoleStore.Delete(roleId)
  5330  
  5331  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5332  	if s.Root.Metrics != nil {
  5333  		success := "false"
  5334  		if err == nil {
  5335  			success = "true"
  5336  		}
  5337  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.Delete", success, elapsed)
  5338  	}
  5339  	return result, err
  5340  }
  5341  
  5342  func (s *TimerLayerRoleStore) Get(roleId string) (*model.Role, error) {
  5343  	start := timemodule.Now()
  5344  
  5345  	result, err := s.RoleStore.Get(roleId)
  5346  
  5347  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5348  	if s.Root.Metrics != nil {
  5349  		success := "false"
  5350  		if err == nil {
  5351  			success = "true"
  5352  		}
  5353  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.Get", success, elapsed)
  5354  	}
  5355  	return result, err
  5356  }
  5357  
  5358  func (s *TimerLayerRoleStore) GetAll() ([]*model.Role, error) {
  5359  	start := timemodule.Now()
  5360  
  5361  	result, err := s.RoleStore.GetAll()
  5362  
  5363  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5364  	if s.Root.Metrics != nil {
  5365  		success := "false"
  5366  		if err == nil {
  5367  			success = "true"
  5368  		}
  5369  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.GetAll", success, elapsed)
  5370  	}
  5371  	return result, err
  5372  }
  5373  
  5374  func (s *TimerLayerRoleStore) GetByName(name string) (*model.Role, error) {
  5375  	start := timemodule.Now()
  5376  
  5377  	result, err := s.RoleStore.GetByName(name)
  5378  
  5379  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5380  	if s.Root.Metrics != nil {
  5381  		success := "false"
  5382  		if err == nil {
  5383  			success = "true"
  5384  		}
  5385  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.GetByName", success, elapsed)
  5386  	}
  5387  	return result, err
  5388  }
  5389  
  5390  func (s *TimerLayerRoleStore) GetByNames(names []string) ([]*model.Role, error) {
  5391  	start := timemodule.Now()
  5392  
  5393  	result, err := s.RoleStore.GetByNames(names)
  5394  
  5395  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5396  	if s.Root.Metrics != nil {
  5397  		success := "false"
  5398  		if err == nil {
  5399  			success = "true"
  5400  		}
  5401  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.GetByNames", success, elapsed)
  5402  	}
  5403  	return result, err
  5404  }
  5405  
  5406  func (s *TimerLayerRoleStore) PermanentDeleteAll() error {
  5407  	start := timemodule.Now()
  5408  
  5409  	err := s.RoleStore.PermanentDeleteAll()
  5410  
  5411  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5412  	if s.Root.Metrics != nil {
  5413  		success := "false"
  5414  		if err == nil {
  5415  			success = "true"
  5416  		}
  5417  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.PermanentDeleteAll", success, elapsed)
  5418  	}
  5419  	return err
  5420  }
  5421  
  5422  func (s *TimerLayerRoleStore) Save(role *model.Role) (*model.Role, error) {
  5423  	start := timemodule.Now()
  5424  
  5425  	result, err := s.RoleStore.Save(role)
  5426  
  5427  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5428  	if s.Root.Metrics != nil {
  5429  		success := "false"
  5430  		if err == nil {
  5431  			success = "true"
  5432  		}
  5433  		s.Root.Metrics.ObserveStoreMethodDuration("RoleStore.Save", success, elapsed)
  5434  	}
  5435  	return result, err
  5436  }
  5437  
  5438  func (s *TimerLayerSchemeStore) CountByScope(scope string) (int64, error) {
  5439  	start := timemodule.Now()
  5440  
  5441  	result, err := s.SchemeStore.CountByScope(scope)
  5442  
  5443  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5444  	if s.Root.Metrics != nil {
  5445  		success := "false"
  5446  		if err == nil {
  5447  			success = "true"
  5448  		}
  5449  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.CountByScope", success, elapsed)
  5450  	}
  5451  	return result, err
  5452  }
  5453  
  5454  func (s *TimerLayerSchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error) {
  5455  	start := timemodule.Now()
  5456  
  5457  	result, err := s.SchemeStore.CountWithoutPermission(scope, permissionID, roleScope, roleType)
  5458  
  5459  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5460  	if s.Root.Metrics != nil {
  5461  		success := "false"
  5462  		if err == nil {
  5463  			success = "true"
  5464  		}
  5465  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.CountWithoutPermission", success, elapsed)
  5466  	}
  5467  	return result, err
  5468  }
  5469  
  5470  func (s *TimerLayerSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
  5471  	start := timemodule.Now()
  5472  
  5473  	result, err := s.SchemeStore.Delete(schemeId)
  5474  
  5475  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5476  	if s.Root.Metrics != nil {
  5477  		success := "false"
  5478  		if err == nil {
  5479  			success = "true"
  5480  		}
  5481  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.Delete", success, elapsed)
  5482  	}
  5483  	return result, err
  5484  }
  5485  
  5486  func (s *TimerLayerSchemeStore) Get(schemeId string) (*model.Scheme, error) {
  5487  	start := timemodule.Now()
  5488  
  5489  	result, err := s.SchemeStore.Get(schemeId)
  5490  
  5491  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5492  	if s.Root.Metrics != nil {
  5493  		success := "false"
  5494  		if err == nil {
  5495  			success = "true"
  5496  		}
  5497  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.Get", success, elapsed)
  5498  	}
  5499  	return result, err
  5500  }
  5501  
  5502  func (s *TimerLayerSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error) {
  5503  	start := timemodule.Now()
  5504  
  5505  	result, err := s.SchemeStore.GetAllPage(scope, offset, limit)
  5506  
  5507  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5508  	if s.Root.Metrics != nil {
  5509  		success := "false"
  5510  		if err == nil {
  5511  			success = "true"
  5512  		}
  5513  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.GetAllPage", success, elapsed)
  5514  	}
  5515  	return result, err
  5516  }
  5517  
  5518  func (s *TimerLayerSchemeStore) GetByName(schemeName string) (*model.Scheme, error) {
  5519  	start := timemodule.Now()
  5520  
  5521  	result, err := s.SchemeStore.GetByName(schemeName)
  5522  
  5523  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5524  	if s.Root.Metrics != nil {
  5525  		success := "false"
  5526  		if err == nil {
  5527  			success = "true"
  5528  		}
  5529  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.GetByName", success, elapsed)
  5530  	}
  5531  	return result, err
  5532  }
  5533  
  5534  func (s *TimerLayerSchemeStore) PermanentDeleteAll() error {
  5535  	start := timemodule.Now()
  5536  
  5537  	err := s.SchemeStore.PermanentDeleteAll()
  5538  
  5539  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5540  	if s.Root.Metrics != nil {
  5541  		success := "false"
  5542  		if err == nil {
  5543  			success = "true"
  5544  		}
  5545  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.PermanentDeleteAll", success, elapsed)
  5546  	}
  5547  	return err
  5548  }
  5549  
  5550  func (s *TimerLayerSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
  5551  	start := timemodule.Now()
  5552  
  5553  	result, err := s.SchemeStore.Save(scheme)
  5554  
  5555  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5556  	if s.Root.Metrics != nil {
  5557  		success := "false"
  5558  		if err == nil {
  5559  			success = "true"
  5560  		}
  5561  		s.Root.Metrics.ObserveStoreMethodDuration("SchemeStore.Save", success, elapsed)
  5562  	}
  5563  	return result, err
  5564  }
  5565  
  5566  func (s *TimerLayerSessionStore) AnalyticsSessionCount() (int64, error) {
  5567  	start := timemodule.Now()
  5568  
  5569  	result, err := s.SessionStore.AnalyticsSessionCount()
  5570  
  5571  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5572  	if s.Root.Metrics != nil {
  5573  		success := "false"
  5574  		if err == nil {
  5575  			success = "true"
  5576  		}
  5577  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.AnalyticsSessionCount", success, elapsed)
  5578  	}
  5579  	return result, err
  5580  }
  5581  
  5582  func (s *TimerLayerSessionStore) Cleanup(expiryTime int64, batchSize int64) {
  5583  	start := timemodule.Now()
  5584  
  5585  	s.SessionStore.Cleanup(expiryTime, batchSize)
  5586  
  5587  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5588  	if s.Root.Metrics != nil {
  5589  		success := "false"
  5590  		if true {
  5591  			success = "true"
  5592  		}
  5593  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.Cleanup", success, elapsed)
  5594  	}
  5595  }
  5596  
  5597  func (s *TimerLayerSessionStore) Get(sessionIdOrToken string) (*model.Session, error) {
  5598  	start := timemodule.Now()
  5599  
  5600  	result, err := s.SessionStore.Get(sessionIdOrToken)
  5601  
  5602  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5603  	if s.Root.Metrics != nil {
  5604  		success := "false"
  5605  		if err == nil {
  5606  			success = "true"
  5607  		}
  5608  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.Get", success, elapsed)
  5609  	}
  5610  	return result, err
  5611  }
  5612  
  5613  func (s *TimerLayerSessionStore) GetSessions(userId string) ([]*model.Session, error) {
  5614  	start := timemodule.Now()
  5615  
  5616  	result, err := s.SessionStore.GetSessions(userId)
  5617  
  5618  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5619  	if s.Root.Metrics != nil {
  5620  		success := "false"
  5621  		if err == nil {
  5622  			success = "true"
  5623  		}
  5624  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.GetSessions", success, elapsed)
  5625  	}
  5626  	return result, err
  5627  }
  5628  
  5629  func (s *TimerLayerSessionStore) GetSessionsExpired(thresholdMillis int64, mobileOnly bool, unnotifiedOnly bool) ([]*model.Session, error) {
  5630  	start := timemodule.Now()
  5631  
  5632  	result, err := s.SessionStore.GetSessionsExpired(thresholdMillis, mobileOnly, unnotifiedOnly)
  5633  
  5634  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5635  	if s.Root.Metrics != nil {
  5636  		success := "false"
  5637  		if err == nil {
  5638  			success = "true"
  5639  		}
  5640  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.GetSessionsExpired", success, elapsed)
  5641  	}
  5642  	return result, err
  5643  }
  5644  
  5645  func (s *TimerLayerSessionStore) GetSessionsWithActiveDeviceIds(userId string) ([]*model.Session, error) {
  5646  	start := timemodule.Now()
  5647  
  5648  	result, err := s.SessionStore.GetSessionsWithActiveDeviceIds(userId)
  5649  
  5650  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5651  	if s.Root.Metrics != nil {
  5652  		success := "false"
  5653  		if err == nil {
  5654  			success = "true"
  5655  		}
  5656  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.GetSessionsWithActiveDeviceIds", success, elapsed)
  5657  	}
  5658  	return result, err
  5659  }
  5660  
  5661  func (s *TimerLayerSessionStore) PermanentDeleteSessionsByUser(teamId string) error {
  5662  	start := timemodule.Now()
  5663  
  5664  	err := s.SessionStore.PermanentDeleteSessionsByUser(teamId)
  5665  
  5666  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5667  	if s.Root.Metrics != nil {
  5668  		success := "false"
  5669  		if err == nil {
  5670  			success = "true"
  5671  		}
  5672  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.PermanentDeleteSessionsByUser", success, elapsed)
  5673  	}
  5674  	return err
  5675  }
  5676  
  5677  func (s *TimerLayerSessionStore) Remove(sessionIdOrToken string) error {
  5678  	start := timemodule.Now()
  5679  
  5680  	err := s.SessionStore.Remove(sessionIdOrToken)
  5681  
  5682  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5683  	if s.Root.Metrics != nil {
  5684  		success := "false"
  5685  		if err == nil {
  5686  			success = "true"
  5687  		}
  5688  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.Remove", success, elapsed)
  5689  	}
  5690  	return err
  5691  }
  5692  
  5693  func (s *TimerLayerSessionStore) RemoveAllSessions() error {
  5694  	start := timemodule.Now()
  5695  
  5696  	err := s.SessionStore.RemoveAllSessions()
  5697  
  5698  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5699  	if s.Root.Metrics != nil {
  5700  		success := "false"
  5701  		if err == nil {
  5702  			success = "true"
  5703  		}
  5704  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.RemoveAllSessions", success, elapsed)
  5705  	}
  5706  	return err
  5707  }
  5708  
  5709  func (s *TimerLayerSessionStore) Save(session *model.Session) (*model.Session, error) {
  5710  	start := timemodule.Now()
  5711  
  5712  	result, err := s.SessionStore.Save(session)
  5713  
  5714  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5715  	if s.Root.Metrics != nil {
  5716  		success := "false"
  5717  		if err == nil {
  5718  			success = "true"
  5719  		}
  5720  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.Save", success, elapsed)
  5721  	}
  5722  	return result, err
  5723  }
  5724  
  5725  func (s *TimerLayerSessionStore) UpdateDeviceId(id string, deviceId string, expiresAt int64) (string, error) {
  5726  	start := timemodule.Now()
  5727  
  5728  	result, err := s.SessionStore.UpdateDeviceId(id, deviceId, expiresAt)
  5729  
  5730  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5731  	if s.Root.Metrics != nil {
  5732  		success := "false"
  5733  		if err == nil {
  5734  			success = "true"
  5735  		}
  5736  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.UpdateDeviceId", success, elapsed)
  5737  	}
  5738  	return result, err
  5739  }
  5740  
  5741  func (s *TimerLayerSessionStore) UpdateExpiredNotify(sessionid string, notified bool) error {
  5742  	start := timemodule.Now()
  5743  
  5744  	err := s.SessionStore.UpdateExpiredNotify(sessionid, notified)
  5745  
  5746  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5747  	if s.Root.Metrics != nil {
  5748  		success := "false"
  5749  		if err == nil {
  5750  			success = "true"
  5751  		}
  5752  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.UpdateExpiredNotify", success, elapsed)
  5753  	}
  5754  	return err
  5755  }
  5756  
  5757  func (s *TimerLayerSessionStore) UpdateExpiresAt(sessionId string, time int64) error {
  5758  	start := timemodule.Now()
  5759  
  5760  	err := s.SessionStore.UpdateExpiresAt(sessionId, time)
  5761  
  5762  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5763  	if s.Root.Metrics != nil {
  5764  		success := "false"
  5765  		if err == nil {
  5766  			success = "true"
  5767  		}
  5768  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.UpdateExpiresAt", success, elapsed)
  5769  	}
  5770  	return err
  5771  }
  5772  
  5773  func (s *TimerLayerSessionStore) UpdateLastActivityAt(sessionId string, time int64) error {
  5774  	start := timemodule.Now()
  5775  
  5776  	err := s.SessionStore.UpdateLastActivityAt(sessionId, time)
  5777  
  5778  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5779  	if s.Root.Metrics != nil {
  5780  		success := "false"
  5781  		if err == nil {
  5782  			success = "true"
  5783  		}
  5784  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.UpdateLastActivityAt", success, elapsed)
  5785  	}
  5786  	return err
  5787  }
  5788  
  5789  func (s *TimerLayerSessionStore) UpdateProps(session *model.Session) error {
  5790  	start := timemodule.Now()
  5791  
  5792  	err := s.SessionStore.UpdateProps(session)
  5793  
  5794  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5795  	if s.Root.Metrics != nil {
  5796  		success := "false"
  5797  		if err == nil {
  5798  			success = "true"
  5799  		}
  5800  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.UpdateProps", success, elapsed)
  5801  	}
  5802  	return err
  5803  }
  5804  
  5805  func (s *TimerLayerSessionStore) UpdateRoles(userId string, roles string) (string, error) {
  5806  	start := timemodule.Now()
  5807  
  5808  	result, err := s.SessionStore.UpdateRoles(userId, roles)
  5809  
  5810  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5811  	if s.Root.Metrics != nil {
  5812  		success := "false"
  5813  		if err == nil {
  5814  			success = "true"
  5815  		}
  5816  		s.Root.Metrics.ObserveStoreMethodDuration("SessionStore.UpdateRoles", success, elapsed)
  5817  	}
  5818  	return result, err
  5819  }
  5820  
  5821  func (s *TimerLayerStatusStore) Get(userId string) (*model.Status, error) {
  5822  	start := timemodule.Now()
  5823  
  5824  	result, err := s.StatusStore.Get(userId)
  5825  
  5826  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5827  	if s.Root.Metrics != nil {
  5828  		success := "false"
  5829  		if err == nil {
  5830  			success = "true"
  5831  		}
  5832  		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.Get", success, elapsed)
  5833  	}
  5834  	return result, err
  5835  }
  5836  
  5837  func (s *TimerLayerStatusStore) GetByIds(userIds []string) ([]*model.Status, error) {
  5838  	start := timemodule.Now()
  5839  
  5840  	result, err := s.StatusStore.GetByIds(userIds)
  5841  
  5842  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5843  	if s.Root.Metrics != nil {
  5844  		success := "false"
  5845  		if err == nil {
  5846  			success = "true"
  5847  		}
  5848  		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.GetByIds", success, elapsed)
  5849  	}
  5850  	return result, err
  5851  }
  5852  
  5853  func (s *TimerLayerStatusStore) GetTotalActiveUsersCount() (int64, error) {
  5854  	start := timemodule.Now()
  5855  
  5856  	result, err := s.StatusStore.GetTotalActiveUsersCount()
  5857  
  5858  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5859  	if s.Root.Metrics != nil {
  5860  		success := "false"
  5861  		if err == nil {
  5862  			success = "true"
  5863  		}
  5864  		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.GetTotalActiveUsersCount", success, elapsed)
  5865  	}
  5866  	return result, err
  5867  }
  5868  
  5869  func (s *TimerLayerStatusStore) ResetAll() error {
  5870  	start := timemodule.Now()
  5871  
  5872  	err := s.StatusStore.ResetAll()
  5873  
  5874  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5875  	if s.Root.Metrics != nil {
  5876  		success := "false"
  5877  		if err == nil {
  5878  			success = "true"
  5879  		}
  5880  		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.ResetAll", success, elapsed)
  5881  	}
  5882  	return err
  5883  }
  5884  
  5885  func (s *TimerLayerStatusStore) SaveOrUpdate(status *model.Status) error {
  5886  	start := timemodule.Now()
  5887  
  5888  	err := s.StatusStore.SaveOrUpdate(status)
  5889  
  5890  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5891  	if s.Root.Metrics != nil {
  5892  		success := "false"
  5893  		if err == nil {
  5894  			success = "true"
  5895  		}
  5896  		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.SaveOrUpdate", success, elapsed)
  5897  	}
  5898  	return err
  5899  }
  5900  
  5901  func (s *TimerLayerStatusStore) UpdateLastActivityAt(userId string, lastActivityAt int64) error {
  5902  	start := timemodule.Now()
  5903  
  5904  	err := s.StatusStore.UpdateLastActivityAt(userId, lastActivityAt)
  5905  
  5906  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5907  	if s.Root.Metrics != nil {
  5908  		success := "false"
  5909  		if err == nil {
  5910  			success = "true"
  5911  		}
  5912  		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.UpdateLastActivityAt", success, elapsed)
  5913  	}
  5914  	return err
  5915  }
  5916  
  5917  func (s *TimerLayerSystemStore) Get() (model.StringMap, error) {
  5918  	start := timemodule.Now()
  5919  
  5920  	result, err := s.SystemStore.Get()
  5921  
  5922  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5923  	if s.Root.Metrics != nil {
  5924  		success := "false"
  5925  		if err == nil {
  5926  			success = "true"
  5927  		}
  5928  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.Get", success, elapsed)
  5929  	}
  5930  	return result, err
  5931  }
  5932  
  5933  func (s *TimerLayerSystemStore) GetByName(name string) (*model.System, error) {
  5934  	start := timemodule.Now()
  5935  
  5936  	result, err := s.SystemStore.GetByName(name)
  5937  
  5938  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5939  	if s.Root.Metrics != nil {
  5940  		success := "false"
  5941  		if err == nil {
  5942  			success = "true"
  5943  		}
  5944  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.GetByName", success, elapsed)
  5945  	}
  5946  	return result, err
  5947  }
  5948  
  5949  func (s *TimerLayerSystemStore) InsertIfExists(system *model.System) (*model.System, error) {
  5950  	start := timemodule.Now()
  5951  
  5952  	result, err := s.SystemStore.InsertIfExists(system)
  5953  
  5954  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5955  	if s.Root.Metrics != nil {
  5956  		success := "false"
  5957  		if err == nil {
  5958  			success = "true"
  5959  		}
  5960  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.InsertIfExists", success, elapsed)
  5961  	}
  5962  	return result, err
  5963  }
  5964  
  5965  func (s *TimerLayerSystemStore) PermanentDeleteByName(name string) (*model.System, error) {
  5966  	start := timemodule.Now()
  5967  
  5968  	result, err := s.SystemStore.PermanentDeleteByName(name)
  5969  
  5970  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5971  	if s.Root.Metrics != nil {
  5972  		success := "false"
  5973  		if err == nil {
  5974  			success = "true"
  5975  		}
  5976  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.PermanentDeleteByName", success, elapsed)
  5977  	}
  5978  	return result, err
  5979  }
  5980  
  5981  func (s *TimerLayerSystemStore) Save(system *model.System) error {
  5982  	start := timemodule.Now()
  5983  
  5984  	err := s.SystemStore.Save(system)
  5985  
  5986  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  5987  	if s.Root.Metrics != nil {
  5988  		success := "false"
  5989  		if err == nil {
  5990  			success = "true"
  5991  		}
  5992  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.Save", success, elapsed)
  5993  	}
  5994  	return err
  5995  }
  5996  
  5997  func (s *TimerLayerSystemStore) SaveOrUpdate(system *model.System) error {
  5998  	start := timemodule.Now()
  5999  
  6000  	err := s.SystemStore.SaveOrUpdate(system)
  6001  
  6002  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6003  	if s.Root.Metrics != nil {
  6004  		success := "false"
  6005  		if err == nil {
  6006  			success = "true"
  6007  		}
  6008  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.SaveOrUpdate", success, elapsed)
  6009  	}
  6010  	return err
  6011  }
  6012  
  6013  func (s *TimerLayerSystemStore) SaveOrUpdateWithWarnMetricHandling(system *model.System) error {
  6014  	start := timemodule.Now()
  6015  
  6016  	err := s.SystemStore.SaveOrUpdateWithWarnMetricHandling(system)
  6017  
  6018  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6019  	if s.Root.Metrics != nil {
  6020  		success := "false"
  6021  		if err == nil {
  6022  			success = "true"
  6023  		}
  6024  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.SaveOrUpdateWithWarnMetricHandling", success, elapsed)
  6025  	}
  6026  	return err
  6027  }
  6028  
  6029  func (s *TimerLayerSystemStore) Update(system *model.System) error {
  6030  	start := timemodule.Now()
  6031  
  6032  	err := s.SystemStore.Update(system)
  6033  
  6034  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6035  	if s.Root.Metrics != nil {
  6036  		success := "false"
  6037  		if err == nil {
  6038  			success = "true"
  6039  		}
  6040  		s.Root.Metrics.ObserveStoreMethodDuration("SystemStore.Update", success, elapsed)
  6041  	}
  6042  	return err
  6043  }
  6044  
  6045  func (s *TimerLayerTeamStore) AnalyticsGetTeamCountForScheme(schemeId string) (int64, error) {
  6046  	start := timemodule.Now()
  6047  
  6048  	result, err := s.TeamStore.AnalyticsGetTeamCountForScheme(schemeId)
  6049  
  6050  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6051  	if s.Root.Metrics != nil {
  6052  		success := "false"
  6053  		if err == nil {
  6054  			success = "true"
  6055  		}
  6056  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.AnalyticsGetTeamCountForScheme", success, elapsed)
  6057  	}
  6058  	return result, err
  6059  }
  6060  
  6061  func (s *TimerLayerTeamStore) AnalyticsPrivateTeamCount() (int64, error) {
  6062  	start := timemodule.Now()
  6063  
  6064  	result, err := s.TeamStore.AnalyticsPrivateTeamCount()
  6065  
  6066  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6067  	if s.Root.Metrics != nil {
  6068  		success := "false"
  6069  		if err == nil {
  6070  			success = "true"
  6071  		}
  6072  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.AnalyticsPrivateTeamCount", success, elapsed)
  6073  	}
  6074  	return result, err
  6075  }
  6076  
  6077  func (s *TimerLayerTeamStore) AnalyticsPublicTeamCount() (int64, error) {
  6078  	start := timemodule.Now()
  6079  
  6080  	result, err := s.TeamStore.AnalyticsPublicTeamCount()
  6081  
  6082  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6083  	if s.Root.Metrics != nil {
  6084  		success := "false"
  6085  		if err == nil {
  6086  			success = "true"
  6087  		}
  6088  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.AnalyticsPublicTeamCount", success, elapsed)
  6089  	}
  6090  	return result, err
  6091  }
  6092  
  6093  func (s *TimerLayerTeamStore) AnalyticsTeamCount(includeDeleted bool) (int64, error) {
  6094  	start := timemodule.Now()
  6095  
  6096  	result, err := s.TeamStore.AnalyticsTeamCount(includeDeleted)
  6097  
  6098  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6099  	if s.Root.Metrics != nil {
  6100  		success := "false"
  6101  		if err == nil {
  6102  			success = "true"
  6103  		}
  6104  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.AnalyticsTeamCount", success, elapsed)
  6105  	}
  6106  	return result, err
  6107  }
  6108  
  6109  func (s *TimerLayerTeamStore) ClearAllCustomRoleAssignments() error {
  6110  	start := timemodule.Now()
  6111  
  6112  	err := s.TeamStore.ClearAllCustomRoleAssignments()
  6113  
  6114  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6115  	if s.Root.Metrics != nil {
  6116  		success := "false"
  6117  		if err == nil {
  6118  			success = "true"
  6119  		}
  6120  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.ClearAllCustomRoleAssignments", success, elapsed)
  6121  	}
  6122  	return err
  6123  }
  6124  
  6125  func (s *TimerLayerTeamStore) ClearCaches() {
  6126  	start := timemodule.Now()
  6127  
  6128  	s.TeamStore.ClearCaches()
  6129  
  6130  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6131  	if s.Root.Metrics != nil {
  6132  		success := "false"
  6133  		if true {
  6134  			success = "true"
  6135  		}
  6136  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.ClearCaches", success, elapsed)
  6137  	}
  6138  }
  6139  
  6140  func (s *TimerLayerTeamStore) Get(id string) (*model.Team, error) {
  6141  	start := timemodule.Now()
  6142  
  6143  	result, err := s.TeamStore.Get(id)
  6144  
  6145  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6146  	if s.Root.Metrics != nil {
  6147  		success := "false"
  6148  		if err == nil {
  6149  			success = "true"
  6150  		}
  6151  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.Get", success, elapsed)
  6152  	}
  6153  	return result, err
  6154  }
  6155  
  6156  func (s *TimerLayerTeamStore) GetActiveMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
  6157  	start := timemodule.Now()
  6158  
  6159  	result, err := s.TeamStore.GetActiveMemberCount(teamId, restrictions)
  6160  
  6161  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6162  	if s.Root.Metrics != nil {
  6163  		success := "false"
  6164  		if err == nil {
  6165  			success = "true"
  6166  		}
  6167  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetActiveMemberCount", success, elapsed)
  6168  	}
  6169  	return result, err
  6170  }
  6171  
  6172  func (s *TimerLayerTeamStore) GetAll() ([]*model.Team, error) {
  6173  	start := timemodule.Now()
  6174  
  6175  	result, err := s.TeamStore.GetAll()
  6176  
  6177  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6178  	if s.Root.Metrics != nil {
  6179  		success := "false"
  6180  		if err == nil {
  6181  			success = "true"
  6182  		}
  6183  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAll", success, elapsed)
  6184  	}
  6185  	return result, err
  6186  }
  6187  
  6188  func (s *TimerLayerTeamStore) GetAllForExportAfter(limit int, afterId string) ([]*model.TeamForExport, error) {
  6189  	start := timemodule.Now()
  6190  
  6191  	result, err := s.TeamStore.GetAllForExportAfter(limit, afterId)
  6192  
  6193  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6194  	if s.Root.Metrics != nil {
  6195  		success := "false"
  6196  		if err == nil {
  6197  			success = "true"
  6198  		}
  6199  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllForExportAfter", success, elapsed)
  6200  	}
  6201  	return result, err
  6202  }
  6203  
  6204  func (s *TimerLayerTeamStore) GetAllPage(offset int, limit int) ([]*model.Team, error) {
  6205  	start := timemodule.Now()
  6206  
  6207  	result, err := s.TeamStore.GetAllPage(offset, limit)
  6208  
  6209  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6210  	if s.Root.Metrics != nil {
  6211  		success := "false"
  6212  		if err == nil {
  6213  			success = "true"
  6214  		}
  6215  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllPage", success, elapsed)
  6216  	}
  6217  	return result, err
  6218  }
  6219  
  6220  func (s *TimerLayerTeamStore) GetAllPrivateTeamListing() ([]*model.Team, error) {
  6221  	start := timemodule.Now()
  6222  
  6223  	result, err := s.TeamStore.GetAllPrivateTeamListing()
  6224  
  6225  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6226  	if s.Root.Metrics != nil {
  6227  		success := "false"
  6228  		if err == nil {
  6229  			success = "true"
  6230  		}
  6231  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllPrivateTeamListing", success, elapsed)
  6232  	}
  6233  	return result, err
  6234  }
  6235  
  6236  func (s *TimerLayerTeamStore) GetAllPrivateTeamPageListing(offset int, limit int) ([]*model.Team, error) {
  6237  	start := timemodule.Now()
  6238  
  6239  	result, err := s.TeamStore.GetAllPrivateTeamPageListing(offset, limit)
  6240  
  6241  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6242  	if s.Root.Metrics != nil {
  6243  		success := "false"
  6244  		if err == nil {
  6245  			success = "true"
  6246  		}
  6247  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllPrivateTeamPageListing", success, elapsed)
  6248  	}
  6249  	return result, err
  6250  }
  6251  
  6252  func (s *TimerLayerTeamStore) GetAllPublicTeamPageListing(offset int, limit int) ([]*model.Team, error) {
  6253  	start := timemodule.Now()
  6254  
  6255  	result, err := s.TeamStore.GetAllPublicTeamPageListing(offset, limit)
  6256  
  6257  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6258  	if s.Root.Metrics != nil {
  6259  		success := "false"
  6260  		if err == nil {
  6261  			success = "true"
  6262  		}
  6263  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllPublicTeamPageListing", success, elapsed)
  6264  	}
  6265  	return result, err
  6266  }
  6267  
  6268  func (s *TimerLayerTeamStore) GetAllTeamListing() ([]*model.Team, error) {
  6269  	start := timemodule.Now()
  6270  
  6271  	result, err := s.TeamStore.GetAllTeamListing()
  6272  
  6273  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6274  	if s.Root.Metrics != nil {
  6275  		success := "false"
  6276  		if err == nil {
  6277  			success = "true"
  6278  		}
  6279  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllTeamListing", success, elapsed)
  6280  	}
  6281  	return result, err
  6282  }
  6283  
  6284  func (s *TimerLayerTeamStore) GetAllTeamPageListing(offset int, limit int) ([]*model.Team, error) {
  6285  	start := timemodule.Now()
  6286  
  6287  	result, err := s.TeamStore.GetAllTeamPageListing(offset, limit)
  6288  
  6289  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6290  	if s.Root.Metrics != nil {
  6291  		success := "false"
  6292  		if err == nil {
  6293  			success = "true"
  6294  		}
  6295  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetAllTeamPageListing", success, elapsed)
  6296  	}
  6297  	return result, err
  6298  }
  6299  
  6300  func (s *TimerLayerTeamStore) GetByInviteId(inviteId string) (*model.Team, error) {
  6301  	start := timemodule.Now()
  6302  
  6303  	result, err := s.TeamStore.GetByInviteId(inviteId)
  6304  
  6305  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6306  	if s.Root.Metrics != nil {
  6307  		success := "false"
  6308  		if err == nil {
  6309  			success = "true"
  6310  		}
  6311  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetByInviteId", success, elapsed)
  6312  	}
  6313  	return result, err
  6314  }
  6315  
  6316  func (s *TimerLayerTeamStore) GetByName(name string) (*model.Team, error) {
  6317  	start := timemodule.Now()
  6318  
  6319  	result, err := s.TeamStore.GetByName(name)
  6320  
  6321  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6322  	if s.Root.Metrics != nil {
  6323  		success := "false"
  6324  		if err == nil {
  6325  			success = "true"
  6326  		}
  6327  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetByName", success, elapsed)
  6328  	}
  6329  	return result, err
  6330  }
  6331  
  6332  func (s *TimerLayerTeamStore) GetByNames(name []string) ([]*model.Team, error) {
  6333  	start := timemodule.Now()
  6334  
  6335  	result, err := s.TeamStore.GetByNames(name)
  6336  
  6337  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6338  	if s.Root.Metrics != nil {
  6339  		success := "false"
  6340  		if err == nil {
  6341  			success = "true"
  6342  		}
  6343  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetByNames", success, elapsed)
  6344  	}
  6345  	return result, err
  6346  }
  6347  
  6348  func (s *TimerLayerTeamStore) GetChannelUnreadsForAllTeams(excludeTeamId string, userId string) ([]*model.ChannelUnread, error) {
  6349  	start := timemodule.Now()
  6350  
  6351  	result, err := s.TeamStore.GetChannelUnreadsForAllTeams(excludeTeamId, userId)
  6352  
  6353  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6354  	if s.Root.Metrics != nil {
  6355  		success := "false"
  6356  		if err == nil {
  6357  			success = "true"
  6358  		}
  6359  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetChannelUnreadsForAllTeams", success, elapsed)
  6360  	}
  6361  	return result, err
  6362  }
  6363  
  6364  func (s *TimerLayerTeamStore) GetChannelUnreadsForTeam(teamId string, userId string) ([]*model.ChannelUnread, error) {
  6365  	start := timemodule.Now()
  6366  
  6367  	result, err := s.TeamStore.GetChannelUnreadsForTeam(teamId, userId)
  6368  
  6369  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6370  	if s.Root.Metrics != nil {
  6371  		success := "false"
  6372  		if err == nil {
  6373  			success = "true"
  6374  		}
  6375  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetChannelUnreadsForTeam", success, elapsed)
  6376  	}
  6377  	return result, err
  6378  }
  6379  
  6380  func (s *TimerLayerTeamStore) GetMember(teamId string, userId string) (*model.TeamMember, error) {
  6381  	start := timemodule.Now()
  6382  
  6383  	result, err := s.TeamStore.GetMember(teamId, userId)
  6384  
  6385  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6386  	if s.Root.Metrics != nil {
  6387  		success := "false"
  6388  		if err == nil {
  6389  			success = "true"
  6390  		}
  6391  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetMember", success, elapsed)
  6392  	}
  6393  	return result, err
  6394  }
  6395  
  6396  func (s *TimerLayerTeamStore) GetMembers(teamId string, offset int, limit int, teamMembersGetOptions *model.TeamMembersGetOptions) ([]*model.TeamMember, error) {
  6397  	start := timemodule.Now()
  6398  
  6399  	result, err := s.TeamStore.GetMembers(teamId, offset, limit, teamMembersGetOptions)
  6400  
  6401  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6402  	if s.Root.Metrics != nil {
  6403  		success := "false"
  6404  		if err == nil {
  6405  			success = "true"
  6406  		}
  6407  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetMembers", success, elapsed)
  6408  	}
  6409  	return result, err
  6410  }
  6411  
  6412  func (s *TimerLayerTeamStore) GetMembersByIds(teamId string, userIds []string, restrictions *model.ViewUsersRestrictions) ([]*model.TeamMember, error) {
  6413  	start := timemodule.Now()
  6414  
  6415  	result, err := s.TeamStore.GetMembersByIds(teamId, userIds, restrictions)
  6416  
  6417  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6418  	if s.Root.Metrics != nil {
  6419  		success := "false"
  6420  		if err == nil {
  6421  			success = "true"
  6422  		}
  6423  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetMembersByIds", success, elapsed)
  6424  	}
  6425  	return result, err
  6426  }
  6427  
  6428  func (s *TimerLayerTeamStore) GetTeamMembersForExport(userId string) ([]*model.TeamMemberForExport, error) {
  6429  	start := timemodule.Now()
  6430  
  6431  	result, err := s.TeamStore.GetTeamMembersForExport(userId)
  6432  
  6433  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6434  	if s.Root.Metrics != nil {
  6435  		success := "false"
  6436  		if err == nil {
  6437  			success = "true"
  6438  		}
  6439  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetTeamMembersForExport", success, elapsed)
  6440  	}
  6441  	return result, err
  6442  }
  6443  
  6444  func (s *TimerLayerTeamStore) GetTeamsByScheme(schemeId string, offset int, limit int) ([]*model.Team, error) {
  6445  	start := timemodule.Now()
  6446  
  6447  	result, err := s.TeamStore.GetTeamsByScheme(schemeId, offset, limit)
  6448  
  6449  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6450  	if s.Root.Metrics != nil {
  6451  		success := "false"
  6452  		if err == nil {
  6453  			success = "true"
  6454  		}
  6455  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetTeamsByScheme", success, elapsed)
  6456  	}
  6457  	return result, err
  6458  }
  6459  
  6460  func (s *TimerLayerTeamStore) GetTeamsByUserId(userId string) ([]*model.Team, error) {
  6461  	start := timemodule.Now()
  6462  
  6463  	result, err := s.TeamStore.GetTeamsByUserId(userId)
  6464  
  6465  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6466  	if s.Root.Metrics != nil {
  6467  		success := "false"
  6468  		if err == nil {
  6469  			success = "true"
  6470  		}
  6471  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetTeamsByUserId", success, elapsed)
  6472  	}
  6473  	return result, err
  6474  }
  6475  
  6476  func (s *TimerLayerTeamStore) GetTeamsForUser(ctx context.Context, userId string) ([]*model.TeamMember, error) {
  6477  	start := timemodule.Now()
  6478  
  6479  	result, err := s.TeamStore.GetTeamsForUser(ctx, userId)
  6480  
  6481  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6482  	if s.Root.Metrics != nil {
  6483  		success := "false"
  6484  		if err == nil {
  6485  			success = "true"
  6486  		}
  6487  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetTeamsForUser", success, elapsed)
  6488  	}
  6489  	return result, err
  6490  }
  6491  
  6492  func (s *TimerLayerTeamStore) GetTeamsForUserWithPagination(userId string, page int, perPage int) ([]*model.TeamMember, error) {
  6493  	start := timemodule.Now()
  6494  
  6495  	result, err := s.TeamStore.GetTeamsForUserWithPagination(userId, page, perPage)
  6496  
  6497  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6498  	if s.Root.Metrics != nil {
  6499  		success := "false"
  6500  		if err == nil {
  6501  			success = "true"
  6502  		}
  6503  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetTeamsForUserWithPagination", success, elapsed)
  6504  	}
  6505  	return result, err
  6506  }
  6507  
  6508  func (s *TimerLayerTeamStore) GetTotalMemberCount(teamId string, restrictions *model.ViewUsersRestrictions) (int64, error) {
  6509  	start := timemodule.Now()
  6510  
  6511  	result, err := s.TeamStore.GetTotalMemberCount(teamId, restrictions)
  6512  
  6513  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6514  	if s.Root.Metrics != nil {
  6515  		success := "false"
  6516  		if err == nil {
  6517  			success = "true"
  6518  		}
  6519  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetTotalMemberCount", success, elapsed)
  6520  	}
  6521  	return result, err
  6522  }
  6523  
  6524  func (s *TimerLayerTeamStore) GetUserTeamIds(userId string, allowFromCache bool) ([]string, error) {
  6525  	start := timemodule.Now()
  6526  
  6527  	result, err := s.TeamStore.GetUserTeamIds(userId, allowFromCache)
  6528  
  6529  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6530  	if s.Root.Metrics != nil {
  6531  		success := "false"
  6532  		if err == nil {
  6533  			success = "true"
  6534  		}
  6535  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GetUserTeamIds", success, elapsed)
  6536  	}
  6537  	return result, err
  6538  }
  6539  
  6540  func (s *TimerLayerTeamStore) GroupSyncedTeamCount() (int64, error) {
  6541  	start := timemodule.Now()
  6542  
  6543  	result, err := s.TeamStore.GroupSyncedTeamCount()
  6544  
  6545  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6546  	if s.Root.Metrics != nil {
  6547  		success := "false"
  6548  		if err == nil {
  6549  			success = "true"
  6550  		}
  6551  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.GroupSyncedTeamCount", success, elapsed)
  6552  	}
  6553  	return result, err
  6554  }
  6555  
  6556  func (s *TimerLayerTeamStore) InvalidateAllTeamIdsForUser(userId string) {
  6557  	start := timemodule.Now()
  6558  
  6559  	s.TeamStore.InvalidateAllTeamIdsForUser(userId)
  6560  
  6561  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6562  	if s.Root.Metrics != nil {
  6563  		success := "false"
  6564  		if true {
  6565  			success = "true"
  6566  		}
  6567  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.InvalidateAllTeamIdsForUser", success, elapsed)
  6568  	}
  6569  }
  6570  
  6571  func (s *TimerLayerTeamStore) MigrateTeamMembers(fromTeamId string, fromUserId string) (map[string]string, error) {
  6572  	start := timemodule.Now()
  6573  
  6574  	result, err := s.TeamStore.MigrateTeamMembers(fromTeamId, fromUserId)
  6575  
  6576  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6577  	if s.Root.Metrics != nil {
  6578  		success := "false"
  6579  		if err == nil {
  6580  			success = "true"
  6581  		}
  6582  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.MigrateTeamMembers", success, elapsed)
  6583  	}
  6584  	return result, err
  6585  }
  6586  
  6587  func (s *TimerLayerTeamStore) PermanentDelete(teamId string) error {
  6588  	start := timemodule.Now()
  6589  
  6590  	err := s.TeamStore.PermanentDelete(teamId)
  6591  
  6592  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6593  	if s.Root.Metrics != nil {
  6594  		success := "false"
  6595  		if err == nil {
  6596  			success = "true"
  6597  		}
  6598  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.PermanentDelete", success, elapsed)
  6599  	}
  6600  	return err
  6601  }
  6602  
  6603  func (s *TimerLayerTeamStore) RemoveAllMembersByTeam(teamId string) error {
  6604  	start := timemodule.Now()
  6605  
  6606  	err := s.TeamStore.RemoveAllMembersByTeam(teamId)
  6607  
  6608  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6609  	if s.Root.Metrics != nil {
  6610  		success := "false"
  6611  		if err == nil {
  6612  			success = "true"
  6613  		}
  6614  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.RemoveAllMembersByTeam", success, elapsed)
  6615  	}
  6616  	return err
  6617  }
  6618  
  6619  func (s *TimerLayerTeamStore) RemoveAllMembersByUser(userId string) error {
  6620  	start := timemodule.Now()
  6621  
  6622  	err := s.TeamStore.RemoveAllMembersByUser(userId)
  6623  
  6624  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6625  	if s.Root.Metrics != nil {
  6626  		success := "false"
  6627  		if err == nil {
  6628  			success = "true"
  6629  		}
  6630  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.RemoveAllMembersByUser", success, elapsed)
  6631  	}
  6632  	return err
  6633  }
  6634  
  6635  func (s *TimerLayerTeamStore) RemoveMember(teamId string, userId string) error {
  6636  	start := timemodule.Now()
  6637  
  6638  	err := s.TeamStore.RemoveMember(teamId, userId)
  6639  
  6640  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6641  	if s.Root.Metrics != nil {
  6642  		success := "false"
  6643  		if err == nil {
  6644  			success = "true"
  6645  		}
  6646  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.RemoveMember", success, elapsed)
  6647  	}
  6648  	return err
  6649  }
  6650  
  6651  func (s *TimerLayerTeamStore) RemoveMembers(teamId string, userIds []string) error {
  6652  	start := timemodule.Now()
  6653  
  6654  	err := s.TeamStore.RemoveMembers(teamId, userIds)
  6655  
  6656  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6657  	if s.Root.Metrics != nil {
  6658  		success := "false"
  6659  		if err == nil {
  6660  			success = "true"
  6661  		}
  6662  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.RemoveMembers", success, elapsed)
  6663  	}
  6664  	return err
  6665  }
  6666  
  6667  func (s *TimerLayerTeamStore) ResetAllTeamSchemes() error {
  6668  	start := timemodule.Now()
  6669  
  6670  	err := s.TeamStore.ResetAllTeamSchemes()
  6671  
  6672  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6673  	if s.Root.Metrics != nil {
  6674  		success := "false"
  6675  		if err == nil {
  6676  			success = "true"
  6677  		}
  6678  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.ResetAllTeamSchemes", success, elapsed)
  6679  	}
  6680  	return err
  6681  }
  6682  
  6683  func (s *TimerLayerTeamStore) Save(team *model.Team) (*model.Team, error) {
  6684  	start := timemodule.Now()
  6685  
  6686  	result, err := s.TeamStore.Save(team)
  6687  
  6688  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6689  	if s.Root.Metrics != nil {
  6690  		success := "false"
  6691  		if err == nil {
  6692  			success = "true"
  6693  		}
  6694  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.Save", success, elapsed)
  6695  	}
  6696  	return result, err
  6697  }
  6698  
  6699  func (s *TimerLayerTeamStore) SaveMember(member *model.TeamMember, maxUsersPerTeam int) (*model.TeamMember, error) {
  6700  	start := timemodule.Now()
  6701  
  6702  	result, err := s.TeamStore.SaveMember(member, maxUsersPerTeam)
  6703  
  6704  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6705  	if s.Root.Metrics != nil {
  6706  		success := "false"
  6707  		if err == nil {
  6708  			success = "true"
  6709  		}
  6710  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.SaveMember", success, elapsed)
  6711  	}
  6712  	return result, err
  6713  }
  6714  
  6715  func (s *TimerLayerTeamStore) SaveMultipleMembers(members []*model.TeamMember, maxUsersPerTeam int) ([]*model.TeamMember, error) {
  6716  	start := timemodule.Now()
  6717  
  6718  	result, err := s.TeamStore.SaveMultipleMembers(members, maxUsersPerTeam)
  6719  
  6720  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6721  	if s.Root.Metrics != nil {
  6722  		success := "false"
  6723  		if err == nil {
  6724  			success = "true"
  6725  		}
  6726  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.SaveMultipleMembers", success, elapsed)
  6727  	}
  6728  	return result, err
  6729  }
  6730  
  6731  func (s *TimerLayerTeamStore) SearchAll(term string, opts *model.TeamSearch) ([]*model.Team, error) {
  6732  	start := timemodule.Now()
  6733  
  6734  	result, err := s.TeamStore.SearchAll(term, opts)
  6735  
  6736  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6737  	if s.Root.Metrics != nil {
  6738  		success := "false"
  6739  		if err == nil {
  6740  			success = "true"
  6741  		}
  6742  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.SearchAll", success, elapsed)
  6743  	}
  6744  	return result, err
  6745  }
  6746  
  6747  func (s *TimerLayerTeamStore) SearchAllPaged(term string, opts *model.TeamSearch) ([]*model.Team, int64, error) {
  6748  	start := timemodule.Now()
  6749  
  6750  	result, resultVar1, err := s.TeamStore.SearchAllPaged(term, opts)
  6751  
  6752  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6753  	if s.Root.Metrics != nil {
  6754  		success := "false"
  6755  		if err == nil {
  6756  			success = "true"
  6757  		}
  6758  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.SearchAllPaged", success, elapsed)
  6759  	}
  6760  	return result, resultVar1, err
  6761  }
  6762  
  6763  func (s *TimerLayerTeamStore) SearchOpen(term string) ([]*model.Team, error) {
  6764  	start := timemodule.Now()
  6765  
  6766  	result, err := s.TeamStore.SearchOpen(term)
  6767  
  6768  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6769  	if s.Root.Metrics != nil {
  6770  		success := "false"
  6771  		if err == nil {
  6772  			success = "true"
  6773  		}
  6774  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.SearchOpen", success, elapsed)
  6775  	}
  6776  	return result, err
  6777  }
  6778  
  6779  func (s *TimerLayerTeamStore) SearchPrivate(term string) ([]*model.Team, error) {
  6780  	start := timemodule.Now()
  6781  
  6782  	result, err := s.TeamStore.SearchPrivate(term)
  6783  
  6784  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6785  	if s.Root.Metrics != nil {
  6786  		success := "false"
  6787  		if err == nil {
  6788  			success = "true"
  6789  		}
  6790  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.SearchPrivate", success, elapsed)
  6791  	}
  6792  	return result, err
  6793  }
  6794  
  6795  func (s *TimerLayerTeamStore) Update(team *model.Team) (*model.Team, error) {
  6796  	start := timemodule.Now()
  6797  
  6798  	result, err := s.TeamStore.Update(team)
  6799  
  6800  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6801  	if s.Root.Metrics != nil {
  6802  		success := "false"
  6803  		if err == nil {
  6804  			success = "true"
  6805  		}
  6806  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.Update", success, elapsed)
  6807  	}
  6808  	return result, err
  6809  }
  6810  
  6811  func (s *TimerLayerTeamStore) UpdateLastTeamIconUpdate(teamId string, curTime int64) error {
  6812  	start := timemodule.Now()
  6813  
  6814  	err := s.TeamStore.UpdateLastTeamIconUpdate(teamId, curTime)
  6815  
  6816  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6817  	if s.Root.Metrics != nil {
  6818  		success := "false"
  6819  		if err == nil {
  6820  			success = "true"
  6821  		}
  6822  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.UpdateLastTeamIconUpdate", success, elapsed)
  6823  	}
  6824  	return err
  6825  }
  6826  
  6827  func (s *TimerLayerTeamStore) UpdateMember(member *model.TeamMember) (*model.TeamMember, error) {
  6828  	start := timemodule.Now()
  6829  
  6830  	result, err := s.TeamStore.UpdateMember(member)
  6831  
  6832  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6833  	if s.Root.Metrics != nil {
  6834  		success := "false"
  6835  		if err == nil {
  6836  			success = "true"
  6837  		}
  6838  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.UpdateMember", success, elapsed)
  6839  	}
  6840  	return result, err
  6841  }
  6842  
  6843  func (s *TimerLayerTeamStore) UpdateMembersRole(teamID string, userIDs []string) error {
  6844  	start := timemodule.Now()
  6845  
  6846  	err := s.TeamStore.UpdateMembersRole(teamID, userIDs)
  6847  
  6848  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6849  	if s.Root.Metrics != nil {
  6850  		success := "false"
  6851  		if err == nil {
  6852  			success = "true"
  6853  		}
  6854  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.UpdateMembersRole", success, elapsed)
  6855  	}
  6856  	return err
  6857  }
  6858  
  6859  func (s *TimerLayerTeamStore) UpdateMultipleMembers(members []*model.TeamMember) ([]*model.TeamMember, error) {
  6860  	start := timemodule.Now()
  6861  
  6862  	result, err := s.TeamStore.UpdateMultipleMembers(members)
  6863  
  6864  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6865  	if s.Root.Metrics != nil {
  6866  		success := "false"
  6867  		if err == nil {
  6868  			success = "true"
  6869  		}
  6870  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.UpdateMultipleMembers", success, elapsed)
  6871  	}
  6872  	return result, err
  6873  }
  6874  
  6875  func (s *TimerLayerTeamStore) UserBelongsToTeams(userId string, teamIds []string) (bool, error) {
  6876  	start := timemodule.Now()
  6877  
  6878  	result, err := s.TeamStore.UserBelongsToTeams(userId, teamIds)
  6879  
  6880  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6881  	if s.Root.Metrics != nil {
  6882  		success := "false"
  6883  		if err == nil {
  6884  			success = "true"
  6885  		}
  6886  		s.Root.Metrics.ObserveStoreMethodDuration("TeamStore.UserBelongsToTeams", success, elapsed)
  6887  	}
  6888  	return result, err
  6889  }
  6890  
  6891  func (s *TimerLayerTermsOfServiceStore) Get(id string, allowFromCache bool) (*model.TermsOfService, error) {
  6892  	start := timemodule.Now()
  6893  
  6894  	result, err := s.TermsOfServiceStore.Get(id, allowFromCache)
  6895  
  6896  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6897  	if s.Root.Metrics != nil {
  6898  		success := "false"
  6899  		if err == nil {
  6900  			success = "true"
  6901  		}
  6902  		s.Root.Metrics.ObserveStoreMethodDuration("TermsOfServiceStore.Get", success, elapsed)
  6903  	}
  6904  	return result, err
  6905  }
  6906  
  6907  func (s *TimerLayerTermsOfServiceStore) GetLatest(allowFromCache bool) (*model.TermsOfService, error) {
  6908  	start := timemodule.Now()
  6909  
  6910  	result, err := s.TermsOfServiceStore.GetLatest(allowFromCache)
  6911  
  6912  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6913  	if s.Root.Metrics != nil {
  6914  		success := "false"
  6915  		if err == nil {
  6916  			success = "true"
  6917  		}
  6918  		s.Root.Metrics.ObserveStoreMethodDuration("TermsOfServiceStore.GetLatest", success, elapsed)
  6919  	}
  6920  	return result, err
  6921  }
  6922  
  6923  func (s *TimerLayerTermsOfServiceStore) Save(termsOfService *model.TermsOfService) (*model.TermsOfService, error) {
  6924  	start := timemodule.Now()
  6925  
  6926  	result, err := s.TermsOfServiceStore.Save(termsOfService)
  6927  
  6928  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6929  	if s.Root.Metrics != nil {
  6930  		success := "false"
  6931  		if err == nil {
  6932  			success = "true"
  6933  		}
  6934  		s.Root.Metrics.ObserveStoreMethodDuration("TermsOfServiceStore.Save", success, elapsed)
  6935  	}
  6936  	return result, err
  6937  }
  6938  
  6939  func (s *TimerLayerThreadStore) CollectThreadsWithNewerReplies(userId string, channelIds []string, timestamp int64) ([]string, error) {
  6940  	start := timemodule.Now()
  6941  
  6942  	result, err := s.ThreadStore.CollectThreadsWithNewerReplies(userId, channelIds, timestamp)
  6943  
  6944  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6945  	if s.Root.Metrics != nil {
  6946  		success := "false"
  6947  		if err == nil {
  6948  			success = "true"
  6949  		}
  6950  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.CollectThreadsWithNewerReplies", success, elapsed)
  6951  	}
  6952  	return result, err
  6953  }
  6954  
  6955  func (s *TimerLayerThreadStore) CreateMembershipIfNeeded(userId string, postId string, following bool, incrementMentions bool, updateFollowing bool) error {
  6956  	start := timemodule.Now()
  6957  
  6958  	err := s.ThreadStore.CreateMembershipIfNeeded(userId, postId, following, incrementMentions, updateFollowing)
  6959  
  6960  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6961  	if s.Root.Metrics != nil {
  6962  		success := "false"
  6963  		if err == nil {
  6964  			success = "true"
  6965  		}
  6966  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.CreateMembershipIfNeeded", success, elapsed)
  6967  	}
  6968  	return err
  6969  }
  6970  
  6971  func (s *TimerLayerThreadStore) Delete(postId string) error {
  6972  	start := timemodule.Now()
  6973  
  6974  	err := s.ThreadStore.Delete(postId)
  6975  
  6976  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6977  	if s.Root.Metrics != nil {
  6978  		success := "false"
  6979  		if err == nil {
  6980  			success = "true"
  6981  		}
  6982  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.Delete", success, elapsed)
  6983  	}
  6984  	return err
  6985  }
  6986  
  6987  func (s *TimerLayerThreadStore) DeleteMembershipForUser(userId string, postId string) error {
  6988  	start := timemodule.Now()
  6989  
  6990  	err := s.ThreadStore.DeleteMembershipForUser(userId, postId)
  6991  
  6992  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  6993  	if s.Root.Metrics != nil {
  6994  		success := "false"
  6995  		if err == nil {
  6996  			success = "true"
  6997  		}
  6998  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.DeleteMembershipForUser", success, elapsed)
  6999  	}
  7000  	return err
  7001  }
  7002  
  7003  func (s *TimerLayerThreadStore) Get(id string) (*model.Thread, error) {
  7004  	start := timemodule.Now()
  7005  
  7006  	result, err := s.ThreadStore.Get(id)
  7007  
  7008  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7009  	if s.Root.Metrics != nil {
  7010  		success := "false"
  7011  		if err == nil {
  7012  			success = "true"
  7013  		}
  7014  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.Get", success, elapsed)
  7015  	}
  7016  	return result, err
  7017  }
  7018  
  7019  func (s *TimerLayerThreadStore) GetMembershipForUser(userId string, postId string) (*model.ThreadMembership, error) {
  7020  	start := timemodule.Now()
  7021  
  7022  	result, err := s.ThreadStore.GetMembershipForUser(userId, postId)
  7023  
  7024  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7025  	if s.Root.Metrics != nil {
  7026  		success := "false"
  7027  		if err == nil {
  7028  			success = "true"
  7029  		}
  7030  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.GetMembershipForUser", success, elapsed)
  7031  	}
  7032  	return result, err
  7033  }
  7034  
  7035  func (s *TimerLayerThreadStore) GetMembershipsForUser(userId string, teamId string) ([]*model.ThreadMembership, error) {
  7036  	start := timemodule.Now()
  7037  
  7038  	result, err := s.ThreadStore.GetMembershipsForUser(userId, teamId)
  7039  
  7040  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7041  	if s.Root.Metrics != nil {
  7042  		success := "false"
  7043  		if err == nil {
  7044  			success = "true"
  7045  		}
  7046  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.GetMembershipsForUser", success, elapsed)
  7047  	}
  7048  	return result, err
  7049  }
  7050  
  7051  func (s *TimerLayerThreadStore) GetPosts(threadId string, since int64) ([]*model.Post, error) {
  7052  	start := timemodule.Now()
  7053  
  7054  	result, err := s.ThreadStore.GetPosts(threadId, since)
  7055  
  7056  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7057  	if s.Root.Metrics != nil {
  7058  		success := "false"
  7059  		if err == nil {
  7060  			success = "true"
  7061  		}
  7062  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.GetPosts", success, elapsed)
  7063  	}
  7064  	return result, err
  7065  }
  7066  
  7067  func (s *TimerLayerThreadStore) GetThreadForUser(userId string, teamId string, threadId string, extended bool) (*model.ThreadResponse, error) {
  7068  	start := timemodule.Now()
  7069  
  7070  	result, err := s.ThreadStore.GetThreadForUser(userId, teamId, threadId, extended)
  7071  
  7072  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7073  	if s.Root.Metrics != nil {
  7074  		success := "false"
  7075  		if err == nil {
  7076  			success = "true"
  7077  		}
  7078  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.GetThreadForUser", success, elapsed)
  7079  	}
  7080  	return result, err
  7081  }
  7082  
  7083  func (s *TimerLayerThreadStore) GetThreadMentionsForUserPerChannel(userId string, teamId string) (map[string]int64, error) {
  7084  	start := timemodule.Now()
  7085  
  7086  	result, err := s.ThreadStore.GetThreadMentionsForUserPerChannel(userId, teamId)
  7087  
  7088  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7089  	if s.Root.Metrics != nil {
  7090  		success := "false"
  7091  		if err == nil {
  7092  			success = "true"
  7093  		}
  7094  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.GetThreadMentionsForUserPerChannel", success, elapsed)
  7095  	}
  7096  	return result, err
  7097  }
  7098  
  7099  func (s *TimerLayerThreadStore) GetThreadsForUser(userId string, teamId string, opts model.GetUserThreadsOpts) (*model.Threads, error) {
  7100  	start := timemodule.Now()
  7101  
  7102  	result, err := s.ThreadStore.GetThreadsForUser(userId, teamId, opts)
  7103  
  7104  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7105  	if s.Root.Metrics != nil {
  7106  		success := "false"
  7107  		if err == nil {
  7108  			success = "true"
  7109  		}
  7110  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.GetThreadsForUser", success, elapsed)
  7111  	}
  7112  	return result, err
  7113  }
  7114  
  7115  func (s *TimerLayerThreadStore) MarkAllAsRead(userId string, teamId string) error {
  7116  	start := timemodule.Now()
  7117  
  7118  	err := s.ThreadStore.MarkAllAsRead(userId, teamId)
  7119  
  7120  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7121  	if s.Root.Metrics != nil {
  7122  		success := "false"
  7123  		if err == nil {
  7124  			success = "true"
  7125  		}
  7126  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.MarkAllAsRead", success, elapsed)
  7127  	}
  7128  	return err
  7129  }
  7130  
  7131  func (s *TimerLayerThreadStore) MarkAsRead(userId string, threadId string, timestamp int64) error {
  7132  	start := timemodule.Now()
  7133  
  7134  	err := s.ThreadStore.MarkAsRead(userId, threadId, timestamp)
  7135  
  7136  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7137  	if s.Root.Metrics != nil {
  7138  		success := "false"
  7139  		if err == nil {
  7140  			success = "true"
  7141  		}
  7142  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.MarkAsRead", success, elapsed)
  7143  	}
  7144  	return err
  7145  }
  7146  
  7147  func (s *TimerLayerThreadStore) Save(thread *model.Thread) (*model.Thread, error) {
  7148  	start := timemodule.Now()
  7149  
  7150  	result, err := s.ThreadStore.Save(thread)
  7151  
  7152  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7153  	if s.Root.Metrics != nil {
  7154  		success := "false"
  7155  		if err == nil {
  7156  			success = "true"
  7157  		}
  7158  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.Save", success, elapsed)
  7159  	}
  7160  	return result, err
  7161  }
  7162  
  7163  func (s *TimerLayerThreadStore) SaveMembership(membership *model.ThreadMembership) (*model.ThreadMembership, error) {
  7164  	start := timemodule.Now()
  7165  
  7166  	result, err := s.ThreadStore.SaveMembership(membership)
  7167  
  7168  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7169  	if s.Root.Metrics != nil {
  7170  		success := "false"
  7171  		if err == nil {
  7172  			success = "true"
  7173  		}
  7174  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.SaveMembership", success, elapsed)
  7175  	}
  7176  	return result, err
  7177  }
  7178  
  7179  func (s *TimerLayerThreadStore) SaveMultiple(thread []*model.Thread) ([]*model.Thread, int, error) {
  7180  	start := timemodule.Now()
  7181  
  7182  	result, resultVar1, err := s.ThreadStore.SaveMultiple(thread)
  7183  
  7184  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7185  	if s.Root.Metrics != nil {
  7186  		success := "false"
  7187  		if err == nil {
  7188  			success = "true"
  7189  		}
  7190  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.SaveMultiple", success, elapsed)
  7191  	}
  7192  	return result, resultVar1, err
  7193  }
  7194  
  7195  func (s *TimerLayerThreadStore) Update(thread *model.Thread) (*model.Thread, error) {
  7196  	start := timemodule.Now()
  7197  
  7198  	result, err := s.ThreadStore.Update(thread)
  7199  
  7200  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7201  	if s.Root.Metrics != nil {
  7202  		success := "false"
  7203  		if err == nil {
  7204  			success = "true"
  7205  		}
  7206  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.Update", success, elapsed)
  7207  	}
  7208  	return result, err
  7209  }
  7210  
  7211  func (s *TimerLayerThreadStore) UpdateMembership(membership *model.ThreadMembership) (*model.ThreadMembership, error) {
  7212  	start := timemodule.Now()
  7213  
  7214  	result, err := s.ThreadStore.UpdateMembership(membership)
  7215  
  7216  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7217  	if s.Root.Metrics != nil {
  7218  		success := "false"
  7219  		if err == nil {
  7220  			success = "true"
  7221  		}
  7222  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.UpdateMembership", success, elapsed)
  7223  	}
  7224  	return result, err
  7225  }
  7226  
  7227  func (s *TimerLayerThreadStore) UpdateUnreadsByChannel(userId string, changedThreads []string, timestamp int64, updateViewedTimestamp bool) error {
  7228  	start := timemodule.Now()
  7229  
  7230  	err := s.ThreadStore.UpdateUnreadsByChannel(userId, changedThreads, timestamp, updateViewedTimestamp)
  7231  
  7232  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7233  	if s.Root.Metrics != nil {
  7234  		success := "false"
  7235  		if err == nil {
  7236  			success = "true"
  7237  		}
  7238  		s.Root.Metrics.ObserveStoreMethodDuration("ThreadStore.UpdateUnreadsByChannel", success, elapsed)
  7239  	}
  7240  	return err
  7241  }
  7242  
  7243  func (s *TimerLayerTokenStore) Cleanup() {
  7244  	start := timemodule.Now()
  7245  
  7246  	s.TokenStore.Cleanup()
  7247  
  7248  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7249  	if s.Root.Metrics != nil {
  7250  		success := "false"
  7251  		if true {
  7252  			success = "true"
  7253  		}
  7254  		s.Root.Metrics.ObserveStoreMethodDuration("TokenStore.Cleanup", success, elapsed)
  7255  	}
  7256  }
  7257  
  7258  func (s *TimerLayerTokenStore) Delete(token string) error {
  7259  	start := timemodule.Now()
  7260  
  7261  	err := s.TokenStore.Delete(token)
  7262  
  7263  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7264  	if s.Root.Metrics != nil {
  7265  		success := "false"
  7266  		if err == nil {
  7267  			success = "true"
  7268  		}
  7269  		s.Root.Metrics.ObserveStoreMethodDuration("TokenStore.Delete", success, elapsed)
  7270  	}
  7271  	return err
  7272  }
  7273  
  7274  func (s *TimerLayerTokenStore) GetByToken(token string) (*model.Token, error) {
  7275  	start := timemodule.Now()
  7276  
  7277  	result, err := s.TokenStore.GetByToken(token)
  7278  
  7279  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7280  	if s.Root.Metrics != nil {
  7281  		success := "false"
  7282  		if err == nil {
  7283  			success = "true"
  7284  		}
  7285  		s.Root.Metrics.ObserveStoreMethodDuration("TokenStore.GetByToken", success, elapsed)
  7286  	}
  7287  	return result, err
  7288  }
  7289  
  7290  func (s *TimerLayerTokenStore) RemoveAllTokensByType(tokenType string) error {
  7291  	start := timemodule.Now()
  7292  
  7293  	err := s.TokenStore.RemoveAllTokensByType(tokenType)
  7294  
  7295  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7296  	if s.Root.Metrics != nil {
  7297  		success := "false"
  7298  		if err == nil {
  7299  			success = "true"
  7300  		}
  7301  		s.Root.Metrics.ObserveStoreMethodDuration("TokenStore.RemoveAllTokensByType", success, elapsed)
  7302  	}
  7303  	return err
  7304  }
  7305  
  7306  func (s *TimerLayerTokenStore) Save(recovery *model.Token) error {
  7307  	start := timemodule.Now()
  7308  
  7309  	err := s.TokenStore.Save(recovery)
  7310  
  7311  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7312  	if s.Root.Metrics != nil {
  7313  		success := "false"
  7314  		if err == nil {
  7315  			success = "true"
  7316  		}
  7317  		s.Root.Metrics.ObserveStoreMethodDuration("TokenStore.Save", success, elapsed)
  7318  	}
  7319  	return err
  7320  }
  7321  
  7322  func (s *TimerLayerUploadSessionStore) Delete(id string) error {
  7323  	start := timemodule.Now()
  7324  
  7325  	err := s.UploadSessionStore.Delete(id)
  7326  
  7327  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7328  	if s.Root.Metrics != nil {
  7329  		success := "false"
  7330  		if err == nil {
  7331  			success = "true"
  7332  		}
  7333  		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Delete", success, elapsed)
  7334  	}
  7335  	return err
  7336  }
  7337  
  7338  func (s *TimerLayerUploadSessionStore) Get(id string) (*model.UploadSession, error) {
  7339  	start := timemodule.Now()
  7340  
  7341  	result, err := s.UploadSessionStore.Get(id)
  7342  
  7343  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7344  	if s.Root.Metrics != nil {
  7345  		success := "false"
  7346  		if err == nil {
  7347  			success = "true"
  7348  		}
  7349  		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Get", success, elapsed)
  7350  	}
  7351  	return result, err
  7352  }
  7353  
  7354  func (s *TimerLayerUploadSessionStore) GetForUser(userId string) ([]*model.UploadSession, error) {
  7355  	start := timemodule.Now()
  7356  
  7357  	result, err := s.UploadSessionStore.GetForUser(userId)
  7358  
  7359  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7360  	if s.Root.Metrics != nil {
  7361  		success := "false"
  7362  		if err == nil {
  7363  			success = "true"
  7364  		}
  7365  		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.GetForUser", success, elapsed)
  7366  	}
  7367  	return result, err
  7368  }
  7369  
  7370  func (s *TimerLayerUploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
  7371  	start := timemodule.Now()
  7372  
  7373  	result, err := s.UploadSessionStore.Save(session)
  7374  
  7375  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7376  	if s.Root.Metrics != nil {
  7377  		success := "false"
  7378  		if err == nil {
  7379  			success = "true"
  7380  		}
  7381  		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Save", success, elapsed)
  7382  	}
  7383  	return result, err
  7384  }
  7385  
  7386  func (s *TimerLayerUploadSessionStore) Update(session *model.UploadSession) error {
  7387  	start := timemodule.Now()
  7388  
  7389  	err := s.UploadSessionStore.Update(session)
  7390  
  7391  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7392  	if s.Root.Metrics != nil {
  7393  		success := "false"
  7394  		if err == nil {
  7395  			success = "true"
  7396  		}
  7397  		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Update", success, elapsed)
  7398  	}
  7399  	return err
  7400  }
  7401  
  7402  func (s *TimerLayerUserStore) AnalyticsActiveCount(time int64, options model.UserCountOptions) (int64, error) {
  7403  	start := timemodule.Now()
  7404  
  7405  	result, err := s.UserStore.AnalyticsActiveCount(time, options)
  7406  
  7407  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7408  	if s.Root.Metrics != nil {
  7409  		success := "false"
  7410  		if err == nil {
  7411  			success = "true"
  7412  		}
  7413  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AnalyticsActiveCount", success, elapsed)
  7414  	}
  7415  	return result, err
  7416  }
  7417  
  7418  func (s *TimerLayerUserStore) AnalyticsActiveCountForPeriod(startTime int64, endTime int64, options model.UserCountOptions) (int64, error) {
  7419  	start := timemodule.Now()
  7420  
  7421  	result, err := s.UserStore.AnalyticsActiveCountForPeriod(startTime, endTime, options)
  7422  
  7423  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7424  	if s.Root.Metrics != nil {
  7425  		success := "false"
  7426  		if err == nil {
  7427  			success = "true"
  7428  		}
  7429  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AnalyticsActiveCountForPeriod", success, elapsed)
  7430  	}
  7431  	return result, err
  7432  }
  7433  
  7434  func (s *TimerLayerUserStore) AnalyticsGetExternalUsers(hostDomain string) (bool, error) {
  7435  	start := timemodule.Now()
  7436  
  7437  	result, err := s.UserStore.AnalyticsGetExternalUsers(hostDomain)
  7438  
  7439  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7440  	if s.Root.Metrics != nil {
  7441  		success := "false"
  7442  		if err == nil {
  7443  			success = "true"
  7444  		}
  7445  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AnalyticsGetExternalUsers", success, elapsed)
  7446  	}
  7447  	return result, err
  7448  }
  7449  
  7450  func (s *TimerLayerUserStore) AnalyticsGetGuestCount() (int64, error) {
  7451  	start := timemodule.Now()
  7452  
  7453  	result, err := s.UserStore.AnalyticsGetGuestCount()
  7454  
  7455  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7456  	if s.Root.Metrics != nil {
  7457  		success := "false"
  7458  		if err == nil {
  7459  			success = "true"
  7460  		}
  7461  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AnalyticsGetGuestCount", success, elapsed)
  7462  	}
  7463  	return result, err
  7464  }
  7465  
  7466  func (s *TimerLayerUserStore) AnalyticsGetInactiveUsersCount() (int64, error) {
  7467  	start := timemodule.Now()
  7468  
  7469  	result, err := s.UserStore.AnalyticsGetInactiveUsersCount()
  7470  
  7471  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7472  	if s.Root.Metrics != nil {
  7473  		success := "false"
  7474  		if err == nil {
  7475  			success = "true"
  7476  		}
  7477  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AnalyticsGetInactiveUsersCount", success, elapsed)
  7478  	}
  7479  	return result, err
  7480  }
  7481  
  7482  func (s *TimerLayerUserStore) AnalyticsGetSystemAdminCount() (int64, error) {
  7483  	start := timemodule.Now()
  7484  
  7485  	result, err := s.UserStore.AnalyticsGetSystemAdminCount()
  7486  
  7487  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7488  	if s.Root.Metrics != nil {
  7489  		success := "false"
  7490  		if err == nil {
  7491  			success = "true"
  7492  		}
  7493  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AnalyticsGetSystemAdminCount", success, elapsed)
  7494  	}
  7495  	return result, err
  7496  }
  7497  
  7498  func (s *TimerLayerUserStore) AutocompleteUsersInChannel(teamId string, channelId string, term string, options *model.UserSearchOptions) (*model.UserAutocompleteInChannel, error) {
  7499  	start := timemodule.Now()
  7500  
  7501  	result, err := s.UserStore.AutocompleteUsersInChannel(teamId, channelId, term, options)
  7502  
  7503  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7504  	if s.Root.Metrics != nil {
  7505  		success := "false"
  7506  		if err == nil {
  7507  			success = "true"
  7508  		}
  7509  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.AutocompleteUsersInChannel", success, elapsed)
  7510  	}
  7511  	return result, err
  7512  }
  7513  
  7514  func (s *TimerLayerUserStore) ClearAllCustomRoleAssignments() error {
  7515  	start := timemodule.Now()
  7516  
  7517  	err := s.UserStore.ClearAllCustomRoleAssignments()
  7518  
  7519  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7520  	if s.Root.Metrics != nil {
  7521  		success := "false"
  7522  		if err == nil {
  7523  			success = "true"
  7524  		}
  7525  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.ClearAllCustomRoleAssignments", success, elapsed)
  7526  	}
  7527  	return err
  7528  }
  7529  
  7530  func (s *TimerLayerUserStore) ClearCaches() {
  7531  	start := timemodule.Now()
  7532  
  7533  	s.UserStore.ClearCaches()
  7534  
  7535  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7536  	if s.Root.Metrics != nil {
  7537  		success := "false"
  7538  		if true {
  7539  			success = "true"
  7540  		}
  7541  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.ClearCaches", success, elapsed)
  7542  	}
  7543  }
  7544  
  7545  func (s *TimerLayerUserStore) Count(options model.UserCountOptions) (int64, error) {
  7546  	start := timemodule.Now()
  7547  
  7548  	result, err := s.UserStore.Count(options)
  7549  
  7550  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7551  	if s.Root.Metrics != nil {
  7552  		success := "false"
  7553  		if err == nil {
  7554  			success = "true"
  7555  		}
  7556  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.Count", success, elapsed)
  7557  	}
  7558  	return result, err
  7559  }
  7560  
  7561  func (s *TimerLayerUserStore) DeactivateGuests() ([]string, error) {
  7562  	start := timemodule.Now()
  7563  
  7564  	result, err := s.UserStore.DeactivateGuests()
  7565  
  7566  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7567  	if s.Root.Metrics != nil {
  7568  		success := "false"
  7569  		if err == nil {
  7570  			success = "true"
  7571  		}
  7572  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.DeactivateGuests", success, elapsed)
  7573  	}
  7574  	return result, err
  7575  }
  7576  
  7577  func (s *TimerLayerUserStore) DemoteUserToGuest(userID string) (*model.User, error) {
  7578  	start := timemodule.Now()
  7579  
  7580  	result, err := s.UserStore.DemoteUserToGuest(userID)
  7581  
  7582  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7583  	if s.Root.Metrics != nil {
  7584  		success := "false"
  7585  		if err == nil {
  7586  			success = "true"
  7587  		}
  7588  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.DemoteUserToGuest", success, elapsed)
  7589  	}
  7590  	return result, err
  7591  }
  7592  
  7593  func (s *TimerLayerUserStore) Get(ctx context.Context, id string) (*model.User, error) {
  7594  	start := timemodule.Now()
  7595  
  7596  	result, err := s.UserStore.Get(ctx, id)
  7597  
  7598  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7599  	if s.Root.Metrics != nil {
  7600  		success := "false"
  7601  		if err == nil {
  7602  			success = "true"
  7603  		}
  7604  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.Get", success, elapsed)
  7605  	}
  7606  	return result, err
  7607  }
  7608  
  7609  func (s *TimerLayerUserStore) GetAll() ([]*model.User, error) {
  7610  	start := timemodule.Now()
  7611  
  7612  	result, err := s.UserStore.GetAll()
  7613  
  7614  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7615  	if s.Root.Metrics != nil {
  7616  		success := "false"
  7617  		if err == nil {
  7618  			success = "true"
  7619  		}
  7620  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAll", success, elapsed)
  7621  	}
  7622  	return result, err
  7623  }
  7624  
  7625  func (s *TimerLayerUserStore) GetAllAfter(limit int, afterId string) ([]*model.User, error) {
  7626  	start := timemodule.Now()
  7627  
  7628  	result, err := s.UserStore.GetAllAfter(limit, afterId)
  7629  
  7630  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7631  	if s.Root.Metrics != nil {
  7632  		success := "false"
  7633  		if err == nil {
  7634  			success = "true"
  7635  		}
  7636  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAllAfter", success, elapsed)
  7637  	}
  7638  	return result, err
  7639  }
  7640  
  7641  func (s *TimerLayerUserStore) GetAllNotInAuthService(authServices []string) ([]*model.User, error) {
  7642  	start := timemodule.Now()
  7643  
  7644  	result, err := s.UserStore.GetAllNotInAuthService(authServices)
  7645  
  7646  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7647  	if s.Root.Metrics != nil {
  7648  		success := "false"
  7649  		if err == nil {
  7650  			success = "true"
  7651  		}
  7652  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAllNotInAuthService", success, elapsed)
  7653  	}
  7654  	return result, err
  7655  }
  7656  
  7657  func (s *TimerLayerUserStore) GetAllProfiles(options *model.UserGetOptions) ([]*model.User, error) {
  7658  	start := timemodule.Now()
  7659  
  7660  	result, err := s.UserStore.GetAllProfiles(options)
  7661  
  7662  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7663  	if s.Root.Metrics != nil {
  7664  		success := "false"
  7665  		if err == nil {
  7666  			success = "true"
  7667  		}
  7668  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAllProfiles", success, elapsed)
  7669  	}
  7670  	return result, err
  7671  }
  7672  
  7673  func (s *TimerLayerUserStore) GetAllProfilesInChannel(ctx context.Context, channelId string, allowFromCache bool) (map[string]*model.User, error) {
  7674  	start := timemodule.Now()
  7675  
  7676  	result, err := s.UserStore.GetAllProfilesInChannel(ctx, channelId, allowFromCache)
  7677  
  7678  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7679  	if s.Root.Metrics != nil {
  7680  		success := "false"
  7681  		if err == nil {
  7682  			success = "true"
  7683  		}
  7684  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAllProfilesInChannel", success, elapsed)
  7685  	}
  7686  	return result, err
  7687  }
  7688  
  7689  func (s *TimerLayerUserStore) GetAllUsingAuthService(authService string) ([]*model.User, error) {
  7690  	start := timemodule.Now()
  7691  
  7692  	result, err := s.UserStore.GetAllUsingAuthService(authService)
  7693  
  7694  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7695  	if s.Root.Metrics != nil {
  7696  		success := "false"
  7697  		if err == nil {
  7698  			success = "true"
  7699  		}
  7700  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAllUsingAuthService", success, elapsed)
  7701  	}
  7702  	return result, err
  7703  }
  7704  
  7705  func (s *TimerLayerUserStore) GetAnyUnreadPostCountForChannel(userId string, channelId string) (int64, error) {
  7706  	start := timemodule.Now()
  7707  
  7708  	result, err := s.UserStore.GetAnyUnreadPostCountForChannel(userId, channelId)
  7709  
  7710  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7711  	if s.Root.Metrics != nil {
  7712  		success := "false"
  7713  		if err == nil {
  7714  			success = "true"
  7715  		}
  7716  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetAnyUnreadPostCountForChannel", success, elapsed)
  7717  	}
  7718  	return result, err
  7719  }
  7720  
  7721  func (s *TimerLayerUserStore) GetByAuth(authData *string, authService string) (*model.User, error) {
  7722  	start := timemodule.Now()
  7723  
  7724  	result, err := s.UserStore.GetByAuth(authData, authService)
  7725  
  7726  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7727  	if s.Root.Metrics != nil {
  7728  		success := "false"
  7729  		if err == nil {
  7730  			success = "true"
  7731  		}
  7732  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetByAuth", success, elapsed)
  7733  	}
  7734  	return result, err
  7735  }
  7736  
  7737  func (s *TimerLayerUserStore) GetByEmail(email string) (*model.User, error) {
  7738  	start := timemodule.Now()
  7739  
  7740  	result, err := s.UserStore.GetByEmail(email)
  7741  
  7742  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7743  	if s.Root.Metrics != nil {
  7744  		success := "false"
  7745  		if err == nil {
  7746  			success = "true"
  7747  		}
  7748  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetByEmail", success, elapsed)
  7749  	}
  7750  	return result, err
  7751  }
  7752  
  7753  func (s *TimerLayerUserStore) GetByUsername(username string) (*model.User, error) {
  7754  	start := timemodule.Now()
  7755  
  7756  	result, err := s.UserStore.GetByUsername(username)
  7757  
  7758  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7759  	if s.Root.Metrics != nil {
  7760  		success := "false"
  7761  		if err == nil {
  7762  			success = "true"
  7763  		}
  7764  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetByUsername", success, elapsed)
  7765  	}
  7766  	return result, err
  7767  }
  7768  
  7769  func (s *TimerLayerUserStore) GetChannelGroupUsers(channelID string) ([]*model.User, error) {
  7770  	start := timemodule.Now()
  7771  
  7772  	result, err := s.UserStore.GetChannelGroupUsers(channelID)
  7773  
  7774  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7775  	if s.Root.Metrics != nil {
  7776  		success := "false"
  7777  		if err == nil {
  7778  			success = "true"
  7779  		}
  7780  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetChannelGroupUsers", success, elapsed)
  7781  	}
  7782  	return result, err
  7783  }
  7784  
  7785  func (s *TimerLayerUserStore) GetEtagForAllProfiles() string {
  7786  	start := timemodule.Now()
  7787  
  7788  	result := s.UserStore.GetEtagForAllProfiles()
  7789  
  7790  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7791  	if s.Root.Metrics != nil {
  7792  		success := "false"
  7793  		if true {
  7794  			success = "true"
  7795  		}
  7796  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetEtagForAllProfiles", success, elapsed)
  7797  	}
  7798  	return result
  7799  }
  7800  
  7801  func (s *TimerLayerUserStore) GetEtagForProfiles(teamId string) string {
  7802  	start := timemodule.Now()
  7803  
  7804  	result := s.UserStore.GetEtagForProfiles(teamId)
  7805  
  7806  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7807  	if s.Root.Metrics != nil {
  7808  		success := "false"
  7809  		if true {
  7810  			success = "true"
  7811  		}
  7812  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetEtagForProfiles", success, elapsed)
  7813  	}
  7814  	return result
  7815  }
  7816  
  7817  func (s *TimerLayerUserStore) GetEtagForProfilesNotInTeam(teamId string) string {
  7818  	start := timemodule.Now()
  7819  
  7820  	result := s.UserStore.GetEtagForProfilesNotInTeam(teamId)
  7821  
  7822  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7823  	if s.Root.Metrics != nil {
  7824  		success := "false"
  7825  		if true {
  7826  			success = "true"
  7827  		}
  7828  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetEtagForProfilesNotInTeam", success, elapsed)
  7829  	}
  7830  	return result
  7831  }
  7832  
  7833  func (s *TimerLayerUserStore) GetForLogin(loginId string, allowSignInWithUsername bool, allowSignInWithEmail bool) (*model.User, error) {
  7834  	start := timemodule.Now()
  7835  
  7836  	result, err := s.UserStore.GetForLogin(loginId, allowSignInWithUsername, allowSignInWithEmail)
  7837  
  7838  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7839  	if s.Root.Metrics != nil {
  7840  		success := "false"
  7841  		if err == nil {
  7842  			success = "true"
  7843  		}
  7844  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetForLogin", success, elapsed)
  7845  	}
  7846  	return result, err
  7847  }
  7848  
  7849  func (s *TimerLayerUserStore) GetKnownUsers(userID string) ([]string, error) {
  7850  	start := timemodule.Now()
  7851  
  7852  	result, err := s.UserStore.GetKnownUsers(userID)
  7853  
  7854  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7855  	if s.Root.Metrics != nil {
  7856  		success := "false"
  7857  		if err == nil {
  7858  			success = "true"
  7859  		}
  7860  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetKnownUsers", success, elapsed)
  7861  	}
  7862  	return result, err
  7863  }
  7864  
  7865  func (s *TimerLayerUserStore) GetMany(ctx context.Context, ids []string) ([]*model.User, error) {
  7866  	start := timemodule.Now()
  7867  
  7868  	result, err := s.UserStore.GetMany(ctx, ids)
  7869  
  7870  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7871  	if s.Root.Metrics != nil {
  7872  		success := "false"
  7873  		if err == nil {
  7874  			success = "true"
  7875  		}
  7876  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetMany", success, elapsed)
  7877  	}
  7878  	return result, err
  7879  }
  7880  
  7881  func (s *TimerLayerUserStore) GetNewUsersForTeam(teamId string, offset int, limit int, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, error) {
  7882  	start := timemodule.Now()
  7883  
  7884  	result, err := s.UserStore.GetNewUsersForTeam(teamId, offset, limit, viewRestrictions)
  7885  
  7886  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7887  	if s.Root.Metrics != nil {
  7888  		success := "false"
  7889  		if err == nil {
  7890  			success = "true"
  7891  		}
  7892  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetNewUsersForTeam", success, elapsed)
  7893  	}
  7894  	return result, err
  7895  }
  7896  
  7897  func (s *TimerLayerUserStore) GetProfileByGroupChannelIdsForUser(userId string, channelIds []string) (map[string][]*model.User, error) {
  7898  	start := timemodule.Now()
  7899  
  7900  	result, err := s.UserStore.GetProfileByGroupChannelIdsForUser(userId, channelIds)
  7901  
  7902  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7903  	if s.Root.Metrics != nil {
  7904  		success := "false"
  7905  		if err == nil {
  7906  			success = "true"
  7907  		}
  7908  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfileByGroupChannelIdsForUser", success, elapsed)
  7909  	}
  7910  	return result, err
  7911  }
  7912  
  7913  func (s *TimerLayerUserStore) GetProfileByIds(ctx context.Context, userIds []string, options *store.UserGetByIdsOpts, allowFromCache bool) ([]*model.User, error) {
  7914  	start := timemodule.Now()
  7915  
  7916  	result, err := s.UserStore.GetProfileByIds(ctx, userIds, options, allowFromCache)
  7917  
  7918  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7919  	if s.Root.Metrics != nil {
  7920  		success := "false"
  7921  		if err == nil {
  7922  			success = "true"
  7923  		}
  7924  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfileByIds", success, elapsed)
  7925  	}
  7926  	return result, err
  7927  }
  7928  
  7929  func (s *TimerLayerUserStore) GetProfiles(options *model.UserGetOptions) ([]*model.User, error) {
  7930  	start := timemodule.Now()
  7931  
  7932  	result, err := s.UserStore.GetProfiles(options)
  7933  
  7934  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7935  	if s.Root.Metrics != nil {
  7936  		success := "false"
  7937  		if err == nil {
  7938  			success = "true"
  7939  		}
  7940  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfiles", success, elapsed)
  7941  	}
  7942  	return result, err
  7943  }
  7944  
  7945  func (s *TimerLayerUserStore) GetProfilesByUsernames(usernames []string, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, error) {
  7946  	start := timemodule.Now()
  7947  
  7948  	result, err := s.UserStore.GetProfilesByUsernames(usernames, viewRestrictions)
  7949  
  7950  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7951  	if s.Root.Metrics != nil {
  7952  		success := "false"
  7953  		if err == nil {
  7954  			success = "true"
  7955  		}
  7956  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfilesByUsernames", success, elapsed)
  7957  	}
  7958  	return result, err
  7959  }
  7960  
  7961  func (s *TimerLayerUserStore) GetProfilesInChannel(options *model.UserGetOptions) ([]*model.User, error) {
  7962  	start := timemodule.Now()
  7963  
  7964  	result, err := s.UserStore.GetProfilesInChannel(options)
  7965  
  7966  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7967  	if s.Root.Metrics != nil {
  7968  		success := "false"
  7969  		if err == nil {
  7970  			success = "true"
  7971  		}
  7972  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfilesInChannel", success, elapsed)
  7973  	}
  7974  	return result, err
  7975  }
  7976  
  7977  func (s *TimerLayerUserStore) GetProfilesInChannelByStatus(options *model.UserGetOptions) ([]*model.User, error) {
  7978  	start := timemodule.Now()
  7979  
  7980  	result, err := s.UserStore.GetProfilesInChannelByStatus(options)
  7981  
  7982  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7983  	if s.Root.Metrics != nil {
  7984  		success := "false"
  7985  		if err == nil {
  7986  			success = "true"
  7987  		}
  7988  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfilesInChannelByStatus", success, elapsed)
  7989  	}
  7990  	return result, err
  7991  }
  7992  
  7993  func (s *TimerLayerUserStore) GetProfilesNotInChannel(teamId string, channelId string, groupConstrained bool, offset int, limit int, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, error) {
  7994  	start := timemodule.Now()
  7995  
  7996  	result, err := s.UserStore.GetProfilesNotInChannel(teamId, channelId, groupConstrained, offset, limit, viewRestrictions)
  7997  
  7998  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  7999  	if s.Root.Metrics != nil {
  8000  		success := "false"
  8001  		if err == nil {
  8002  			success = "true"
  8003  		}
  8004  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfilesNotInChannel", success, elapsed)
  8005  	}
  8006  	return result, err
  8007  }
  8008  
  8009  func (s *TimerLayerUserStore) GetProfilesNotInTeam(teamId string, groupConstrained bool, offset int, limit int, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, error) {
  8010  	start := timemodule.Now()
  8011  
  8012  	result, err := s.UserStore.GetProfilesNotInTeam(teamId, groupConstrained, offset, limit, viewRestrictions)
  8013  
  8014  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8015  	if s.Root.Metrics != nil {
  8016  		success := "false"
  8017  		if err == nil {
  8018  			success = "true"
  8019  		}
  8020  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfilesNotInTeam", success, elapsed)
  8021  	}
  8022  	return result, err
  8023  }
  8024  
  8025  func (s *TimerLayerUserStore) GetProfilesWithoutTeam(options *model.UserGetOptions) ([]*model.User, error) {
  8026  	start := timemodule.Now()
  8027  
  8028  	result, err := s.UserStore.GetProfilesWithoutTeam(options)
  8029  
  8030  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8031  	if s.Root.Metrics != nil {
  8032  		success := "false"
  8033  		if err == nil {
  8034  			success = "true"
  8035  		}
  8036  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetProfilesWithoutTeam", success, elapsed)
  8037  	}
  8038  	return result, err
  8039  }
  8040  
  8041  func (s *TimerLayerUserStore) GetRecentlyActiveUsersForTeam(teamId string, offset int, limit int, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, error) {
  8042  	start := timemodule.Now()
  8043  
  8044  	result, err := s.UserStore.GetRecentlyActiveUsersForTeam(teamId, offset, limit, viewRestrictions)
  8045  
  8046  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8047  	if s.Root.Metrics != nil {
  8048  		success := "false"
  8049  		if err == nil {
  8050  			success = "true"
  8051  		}
  8052  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetRecentlyActiveUsersForTeam", success, elapsed)
  8053  	}
  8054  	return result, err
  8055  }
  8056  
  8057  func (s *TimerLayerUserStore) GetSystemAdminProfiles() (map[string]*model.User, error) {
  8058  	start := timemodule.Now()
  8059  
  8060  	result, err := s.UserStore.GetSystemAdminProfiles()
  8061  
  8062  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8063  	if s.Root.Metrics != nil {
  8064  		success := "false"
  8065  		if err == nil {
  8066  			success = "true"
  8067  		}
  8068  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetSystemAdminProfiles", success, elapsed)
  8069  	}
  8070  	return result, err
  8071  }
  8072  
  8073  func (s *TimerLayerUserStore) GetTeamGroupUsers(teamID string) ([]*model.User, error) {
  8074  	start := timemodule.Now()
  8075  
  8076  	result, err := s.UserStore.GetTeamGroupUsers(teamID)
  8077  
  8078  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8079  	if s.Root.Metrics != nil {
  8080  		success := "false"
  8081  		if err == nil {
  8082  			success = "true"
  8083  		}
  8084  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetTeamGroupUsers", success, elapsed)
  8085  	}
  8086  	return result, err
  8087  }
  8088  
  8089  func (s *TimerLayerUserStore) GetUnreadCount(userId string) (int64, error) {
  8090  	start := timemodule.Now()
  8091  
  8092  	result, err := s.UserStore.GetUnreadCount(userId)
  8093  
  8094  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8095  	if s.Root.Metrics != nil {
  8096  		success := "false"
  8097  		if err == nil {
  8098  			success = "true"
  8099  		}
  8100  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetUnreadCount", success, elapsed)
  8101  	}
  8102  	return result, err
  8103  }
  8104  
  8105  func (s *TimerLayerUserStore) GetUnreadCountForChannel(userId string, channelId string) (int64, error) {
  8106  	start := timemodule.Now()
  8107  
  8108  	result, err := s.UserStore.GetUnreadCountForChannel(userId, channelId)
  8109  
  8110  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8111  	if s.Root.Metrics != nil {
  8112  		success := "false"
  8113  		if err == nil {
  8114  			success = "true"
  8115  		}
  8116  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetUnreadCountForChannel", success, elapsed)
  8117  	}
  8118  	return result, err
  8119  }
  8120  
  8121  func (s *TimerLayerUserStore) GetUsersBatchForIndexing(startTime int64, endTime int64, limit int) ([]*model.UserForIndexing, error) {
  8122  	start := timemodule.Now()
  8123  
  8124  	result, err := s.UserStore.GetUsersBatchForIndexing(startTime, endTime, limit)
  8125  
  8126  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8127  	if s.Root.Metrics != nil {
  8128  		success := "false"
  8129  		if err == nil {
  8130  			success = "true"
  8131  		}
  8132  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.GetUsersBatchForIndexing", success, elapsed)
  8133  	}
  8134  	return result, err
  8135  }
  8136  
  8137  func (s *TimerLayerUserStore) InferSystemInstallDate() (int64, error) {
  8138  	start := timemodule.Now()
  8139  
  8140  	result, err := s.UserStore.InferSystemInstallDate()
  8141  
  8142  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8143  	if s.Root.Metrics != nil {
  8144  		success := "false"
  8145  		if err == nil {
  8146  			success = "true"
  8147  		}
  8148  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.InferSystemInstallDate", success, elapsed)
  8149  	}
  8150  	return result, err
  8151  }
  8152  
  8153  func (s *TimerLayerUserStore) InvalidateProfileCacheForUser(userId string) {
  8154  	start := timemodule.Now()
  8155  
  8156  	s.UserStore.InvalidateProfileCacheForUser(userId)
  8157  
  8158  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8159  	if s.Root.Metrics != nil {
  8160  		success := "false"
  8161  		if true {
  8162  			success = "true"
  8163  		}
  8164  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.InvalidateProfileCacheForUser", success, elapsed)
  8165  	}
  8166  }
  8167  
  8168  func (s *TimerLayerUserStore) InvalidateProfilesInChannelCache(channelId string) {
  8169  	start := timemodule.Now()
  8170  
  8171  	s.UserStore.InvalidateProfilesInChannelCache(channelId)
  8172  
  8173  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8174  	if s.Root.Metrics != nil {
  8175  		success := "false"
  8176  		if true {
  8177  			success = "true"
  8178  		}
  8179  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.InvalidateProfilesInChannelCache", success, elapsed)
  8180  	}
  8181  }
  8182  
  8183  func (s *TimerLayerUserStore) InvalidateProfilesInChannelCacheByUser(userId string) {
  8184  	start := timemodule.Now()
  8185  
  8186  	s.UserStore.InvalidateProfilesInChannelCacheByUser(userId)
  8187  
  8188  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8189  	if s.Root.Metrics != nil {
  8190  		success := "false"
  8191  		if true {
  8192  			success = "true"
  8193  		}
  8194  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.InvalidateProfilesInChannelCacheByUser", success, elapsed)
  8195  	}
  8196  }
  8197  
  8198  func (s *TimerLayerUserStore) PermanentDelete(userId string) error {
  8199  	start := timemodule.Now()
  8200  
  8201  	err := s.UserStore.PermanentDelete(userId)
  8202  
  8203  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8204  	if s.Root.Metrics != nil {
  8205  		success := "false"
  8206  		if err == nil {
  8207  			success = "true"
  8208  		}
  8209  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.PermanentDelete", success, elapsed)
  8210  	}
  8211  	return err
  8212  }
  8213  
  8214  func (s *TimerLayerUserStore) PromoteGuestToUser(userID string) error {
  8215  	start := timemodule.Now()
  8216  
  8217  	err := s.UserStore.PromoteGuestToUser(userID)
  8218  
  8219  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8220  	if s.Root.Metrics != nil {
  8221  		success := "false"
  8222  		if err == nil {
  8223  			success = "true"
  8224  		}
  8225  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.PromoteGuestToUser", success, elapsed)
  8226  	}
  8227  	return err
  8228  }
  8229  
  8230  func (s *TimerLayerUserStore) ResetLastPictureUpdate(userId string) error {
  8231  	start := timemodule.Now()
  8232  
  8233  	err := s.UserStore.ResetLastPictureUpdate(userId)
  8234  
  8235  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8236  	if s.Root.Metrics != nil {
  8237  		success := "false"
  8238  		if err == nil {
  8239  			success = "true"
  8240  		}
  8241  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.ResetLastPictureUpdate", success, elapsed)
  8242  	}
  8243  	return err
  8244  }
  8245  
  8246  func (s *TimerLayerUserStore) Save(user *model.User) (*model.User, error) {
  8247  	start := timemodule.Now()
  8248  
  8249  	result, err := s.UserStore.Save(user)
  8250  
  8251  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8252  	if s.Root.Metrics != nil {
  8253  		success := "false"
  8254  		if err == nil {
  8255  			success = "true"
  8256  		}
  8257  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.Save", success, elapsed)
  8258  	}
  8259  	return result, err
  8260  }
  8261  
  8262  func (s *TimerLayerUserStore) Search(teamId string, term string, options *model.UserSearchOptions) ([]*model.User, error) {
  8263  	start := timemodule.Now()
  8264  
  8265  	result, err := s.UserStore.Search(teamId, term, options)
  8266  
  8267  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8268  	if s.Root.Metrics != nil {
  8269  		success := "false"
  8270  		if err == nil {
  8271  			success = "true"
  8272  		}
  8273  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.Search", success, elapsed)
  8274  	}
  8275  	return result, err
  8276  }
  8277  
  8278  func (s *TimerLayerUserStore) SearchInChannel(channelId string, term string, options *model.UserSearchOptions) ([]*model.User, error) {
  8279  	start := timemodule.Now()
  8280  
  8281  	result, err := s.UserStore.SearchInChannel(channelId, term, options)
  8282  
  8283  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8284  	if s.Root.Metrics != nil {
  8285  		success := "false"
  8286  		if err == nil {
  8287  			success = "true"
  8288  		}
  8289  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.SearchInChannel", success, elapsed)
  8290  	}
  8291  	return result, err
  8292  }
  8293  
  8294  func (s *TimerLayerUserStore) SearchInGroup(groupID string, term string, options *model.UserSearchOptions) ([]*model.User, error) {
  8295  	start := timemodule.Now()
  8296  
  8297  	result, err := s.UserStore.SearchInGroup(groupID, term, options)
  8298  
  8299  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8300  	if s.Root.Metrics != nil {
  8301  		success := "false"
  8302  		if err == nil {
  8303  			success = "true"
  8304  		}
  8305  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.SearchInGroup", success, elapsed)
  8306  	}
  8307  	return result, err
  8308  }
  8309  
  8310  func (s *TimerLayerUserStore) SearchNotInChannel(teamId string, channelId string, term string, options *model.UserSearchOptions) ([]*model.User, error) {
  8311  	start := timemodule.Now()
  8312  
  8313  	result, err := s.UserStore.SearchNotInChannel(teamId, channelId, term, options)
  8314  
  8315  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8316  	if s.Root.Metrics != nil {
  8317  		success := "false"
  8318  		if err == nil {
  8319  			success = "true"
  8320  		}
  8321  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.SearchNotInChannel", success, elapsed)
  8322  	}
  8323  	return result, err
  8324  }
  8325  
  8326  func (s *TimerLayerUserStore) SearchNotInTeam(notInTeamId string, term string, options *model.UserSearchOptions) ([]*model.User, error) {
  8327  	start := timemodule.Now()
  8328  
  8329  	result, err := s.UserStore.SearchNotInTeam(notInTeamId, term, options)
  8330  
  8331  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8332  	if s.Root.Metrics != nil {
  8333  		success := "false"
  8334  		if err == nil {
  8335  			success = "true"
  8336  		}
  8337  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.SearchNotInTeam", success, elapsed)
  8338  	}
  8339  	return result, err
  8340  }
  8341  
  8342  func (s *TimerLayerUserStore) SearchWithoutTeam(term string, options *model.UserSearchOptions) ([]*model.User, error) {
  8343  	start := timemodule.Now()
  8344  
  8345  	result, err := s.UserStore.SearchWithoutTeam(term, options)
  8346  
  8347  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8348  	if s.Root.Metrics != nil {
  8349  		success := "false"
  8350  		if err == nil {
  8351  			success = "true"
  8352  		}
  8353  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.SearchWithoutTeam", success, elapsed)
  8354  	}
  8355  	return result, err
  8356  }
  8357  
  8358  func (s *TimerLayerUserStore) Update(user *model.User, allowRoleUpdate bool) (*model.UserUpdate, error) {
  8359  	start := timemodule.Now()
  8360  
  8361  	result, err := s.UserStore.Update(user, allowRoleUpdate)
  8362  
  8363  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8364  	if s.Root.Metrics != nil {
  8365  		success := "false"
  8366  		if err == nil {
  8367  			success = "true"
  8368  		}
  8369  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.Update", success, elapsed)
  8370  	}
  8371  	return result, err
  8372  }
  8373  
  8374  func (s *TimerLayerUserStore) UpdateAuthData(userId string, service string, authData *string, email string, resetMfa bool) (string, error) {
  8375  	start := timemodule.Now()
  8376  
  8377  	result, err := s.UserStore.UpdateAuthData(userId, service, authData, email, resetMfa)
  8378  
  8379  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8380  	if s.Root.Metrics != nil {
  8381  		success := "false"
  8382  		if err == nil {
  8383  			success = "true"
  8384  		}
  8385  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdateAuthData", success, elapsed)
  8386  	}
  8387  	return result, err
  8388  }
  8389  
  8390  func (s *TimerLayerUserStore) UpdateFailedPasswordAttempts(userId string, attempts int) error {
  8391  	start := timemodule.Now()
  8392  
  8393  	err := s.UserStore.UpdateFailedPasswordAttempts(userId, attempts)
  8394  
  8395  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8396  	if s.Root.Metrics != nil {
  8397  		success := "false"
  8398  		if err == nil {
  8399  			success = "true"
  8400  		}
  8401  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdateFailedPasswordAttempts", success, elapsed)
  8402  	}
  8403  	return err
  8404  }
  8405  
  8406  func (s *TimerLayerUserStore) UpdateLastPictureUpdate(userId string) error {
  8407  	start := timemodule.Now()
  8408  
  8409  	err := s.UserStore.UpdateLastPictureUpdate(userId)
  8410  
  8411  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8412  	if s.Root.Metrics != nil {
  8413  		success := "false"
  8414  		if err == nil {
  8415  			success = "true"
  8416  		}
  8417  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdateLastPictureUpdate", success, elapsed)
  8418  	}
  8419  	return err
  8420  }
  8421  
  8422  func (s *TimerLayerUserStore) UpdateMfaActive(userId string, active bool) error {
  8423  	start := timemodule.Now()
  8424  
  8425  	err := s.UserStore.UpdateMfaActive(userId, active)
  8426  
  8427  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8428  	if s.Root.Metrics != nil {
  8429  		success := "false"
  8430  		if err == nil {
  8431  			success = "true"
  8432  		}
  8433  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdateMfaActive", success, elapsed)
  8434  	}
  8435  	return err
  8436  }
  8437  
  8438  func (s *TimerLayerUserStore) UpdateMfaSecret(userId string, secret string) error {
  8439  	start := timemodule.Now()
  8440  
  8441  	err := s.UserStore.UpdateMfaSecret(userId, secret)
  8442  
  8443  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8444  	if s.Root.Metrics != nil {
  8445  		success := "false"
  8446  		if err == nil {
  8447  			success = "true"
  8448  		}
  8449  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdateMfaSecret", success, elapsed)
  8450  	}
  8451  	return err
  8452  }
  8453  
  8454  func (s *TimerLayerUserStore) UpdatePassword(userId string, newPassword string) error {
  8455  	start := timemodule.Now()
  8456  
  8457  	err := s.UserStore.UpdatePassword(userId, newPassword)
  8458  
  8459  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8460  	if s.Root.Metrics != nil {
  8461  		success := "false"
  8462  		if err == nil {
  8463  			success = "true"
  8464  		}
  8465  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdatePassword", success, elapsed)
  8466  	}
  8467  	return err
  8468  }
  8469  
  8470  func (s *TimerLayerUserStore) UpdateUpdateAt(userId string) (int64, error) {
  8471  	start := timemodule.Now()
  8472  
  8473  	result, err := s.UserStore.UpdateUpdateAt(userId)
  8474  
  8475  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8476  	if s.Root.Metrics != nil {
  8477  		success := "false"
  8478  		if err == nil {
  8479  			success = "true"
  8480  		}
  8481  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.UpdateUpdateAt", success, elapsed)
  8482  	}
  8483  	return result, err
  8484  }
  8485  
  8486  func (s *TimerLayerUserStore) VerifyEmail(userId string, email string) (string, error) {
  8487  	start := timemodule.Now()
  8488  
  8489  	result, err := s.UserStore.VerifyEmail(userId, email)
  8490  
  8491  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8492  	if s.Root.Metrics != nil {
  8493  		success := "false"
  8494  		if err == nil {
  8495  			success = "true"
  8496  		}
  8497  		s.Root.Metrics.ObserveStoreMethodDuration("UserStore.VerifyEmail", success, elapsed)
  8498  	}
  8499  	return result, err
  8500  }
  8501  
  8502  func (s *TimerLayerUserAccessTokenStore) Delete(tokenId string) error {
  8503  	start := timemodule.Now()
  8504  
  8505  	err := s.UserAccessTokenStore.Delete(tokenId)
  8506  
  8507  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8508  	if s.Root.Metrics != nil {
  8509  		success := "false"
  8510  		if err == nil {
  8511  			success = "true"
  8512  		}
  8513  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.Delete", success, elapsed)
  8514  	}
  8515  	return err
  8516  }
  8517  
  8518  func (s *TimerLayerUserAccessTokenStore) DeleteAllForUser(userId string) error {
  8519  	start := timemodule.Now()
  8520  
  8521  	err := s.UserAccessTokenStore.DeleteAllForUser(userId)
  8522  
  8523  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8524  	if s.Root.Metrics != nil {
  8525  		success := "false"
  8526  		if err == nil {
  8527  			success = "true"
  8528  		}
  8529  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.DeleteAllForUser", success, elapsed)
  8530  	}
  8531  	return err
  8532  }
  8533  
  8534  func (s *TimerLayerUserAccessTokenStore) Get(tokenId string) (*model.UserAccessToken, error) {
  8535  	start := timemodule.Now()
  8536  
  8537  	result, err := s.UserAccessTokenStore.Get(tokenId)
  8538  
  8539  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8540  	if s.Root.Metrics != nil {
  8541  		success := "false"
  8542  		if err == nil {
  8543  			success = "true"
  8544  		}
  8545  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.Get", success, elapsed)
  8546  	}
  8547  	return result, err
  8548  }
  8549  
  8550  func (s *TimerLayerUserAccessTokenStore) GetAll(offset int, limit int) ([]*model.UserAccessToken, error) {
  8551  	start := timemodule.Now()
  8552  
  8553  	result, err := s.UserAccessTokenStore.GetAll(offset, limit)
  8554  
  8555  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8556  	if s.Root.Metrics != nil {
  8557  		success := "false"
  8558  		if err == nil {
  8559  			success = "true"
  8560  		}
  8561  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.GetAll", success, elapsed)
  8562  	}
  8563  	return result, err
  8564  }
  8565  
  8566  func (s *TimerLayerUserAccessTokenStore) GetByToken(tokenString string) (*model.UserAccessToken, error) {
  8567  	start := timemodule.Now()
  8568  
  8569  	result, err := s.UserAccessTokenStore.GetByToken(tokenString)
  8570  
  8571  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8572  	if s.Root.Metrics != nil {
  8573  		success := "false"
  8574  		if err == nil {
  8575  			success = "true"
  8576  		}
  8577  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.GetByToken", success, elapsed)
  8578  	}
  8579  	return result, err
  8580  }
  8581  
  8582  func (s *TimerLayerUserAccessTokenStore) GetByUser(userId string, page int, perPage int) ([]*model.UserAccessToken, error) {
  8583  	start := timemodule.Now()
  8584  
  8585  	result, err := s.UserAccessTokenStore.GetByUser(userId, page, perPage)
  8586  
  8587  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8588  	if s.Root.Metrics != nil {
  8589  		success := "false"
  8590  		if err == nil {
  8591  			success = "true"
  8592  		}
  8593  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.GetByUser", success, elapsed)
  8594  	}
  8595  	return result, err
  8596  }
  8597  
  8598  func (s *TimerLayerUserAccessTokenStore) Save(token *model.UserAccessToken) (*model.UserAccessToken, error) {
  8599  	start := timemodule.Now()
  8600  
  8601  	result, err := s.UserAccessTokenStore.Save(token)
  8602  
  8603  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8604  	if s.Root.Metrics != nil {
  8605  		success := "false"
  8606  		if err == nil {
  8607  			success = "true"
  8608  		}
  8609  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.Save", success, elapsed)
  8610  	}
  8611  	return result, err
  8612  }
  8613  
  8614  func (s *TimerLayerUserAccessTokenStore) Search(term string) ([]*model.UserAccessToken, error) {
  8615  	start := timemodule.Now()
  8616  
  8617  	result, err := s.UserAccessTokenStore.Search(term)
  8618  
  8619  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8620  	if s.Root.Metrics != nil {
  8621  		success := "false"
  8622  		if err == nil {
  8623  			success = "true"
  8624  		}
  8625  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.Search", success, elapsed)
  8626  	}
  8627  	return result, err
  8628  }
  8629  
  8630  func (s *TimerLayerUserAccessTokenStore) UpdateTokenDisable(tokenId string) error {
  8631  	start := timemodule.Now()
  8632  
  8633  	err := s.UserAccessTokenStore.UpdateTokenDisable(tokenId)
  8634  
  8635  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8636  	if s.Root.Metrics != nil {
  8637  		success := "false"
  8638  		if err == nil {
  8639  			success = "true"
  8640  		}
  8641  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.UpdateTokenDisable", success, elapsed)
  8642  	}
  8643  	return err
  8644  }
  8645  
  8646  func (s *TimerLayerUserAccessTokenStore) UpdateTokenEnable(tokenId string) error {
  8647  	start := timemodule.Now()
  8648  
  8649  	err := s.UserAccessTokenStore.UpdateTokenEnable(tokenId)
  8650  
  8651  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8652  	if s.Root.Metrics != nil {
  8653  		success := "false"
  8654  		if err == nil {
  8655  			success = "true"
  8656  		}
  8657  		s.Root.Metrics.ObserveStoreMethodDuration("UserAccessTokenStore.UpdateTokenEnable", success, elapsed)
  8658  	}
  8659  	return err
  8660  }
  8661  
  8662  func (s *TimerLayerUserTermsOfServiceStore) Delete(userId string, termsOfServiceId string) error {
  8663  	start := timemodule.Now()
  8664  
  8665  	err := s.UserTermsOfServiceStore.Delete(userId, termsOfServiceId)
  8666  
  8667  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8668  	if s.Root.Metrics != nil {
  8669  		success := "false"
  8670  		if err == nil {
  8671  			success = "true"
  8672  		}
  8673  		s.Root.Metrics.ObserveStoreMethodDuration("UserTermsOfServiceStore.Delete", success, elapsed)
  8674  	}
  8675  	return err
  8676  }
  8677  
  8678  func (s *TimerLayerUserTermsOfServiceStore) GetByUser(userId string) (*model.UserTermsOfService, error) {
  8679  	start := timemodule.Now()
  8680  
  8681  	result, err := s.UserTermsOfServiceStore.GetByUser(userId)
  8682  
  8683  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8684  	if s.Root.Metrics != nil {
  8685  		success := "false"
  8686  		if err == nil {
  8687  			success = "true"
  8688  		}
  8689  		s.Root.Metrics.ObserveStoreMethodDuration("UserTermsOfServiceStore.GetByUser", success, elapsed)
  8690  	}
  8691  	return result, err
  8692  }
  8693  
  8694  func (s *TimerLayerUserTermsOfServiceStore) Save(userTermsOfService *model.UserTermsOfService) (*model.UserTermsOfService, error) {
  8695  	start := timemodule.Now()
  8696  
  8697  	result, err := s.UserTermsOfServiceStore.Save(userTermsOfService)
  8698  
  8699  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8700  	if s.Root.Metrics != nil {
  8701  		success := "false"
  8702  		if err == nil {
  8703  			success = "true"
  8704  		}
  8705  		s.Root.Metrics.ObserveStoreMethodDuration("UserTermsOfServiceStore.Save", success, elapsed)
  8706  	}
  8707  	return result, err
  8708  }
  8709  
  8710  func (s *TimerLayerWebhookStore) AnalyticsIncomingCount(teamId string) (int64, error) {
  8711  	start := timemodule.Now()
  8712  
  8713  	result, err := s.WebhookStore.AnalyticsIncomingCount(teamId)
  8714  
  8715  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8716  	if s.Root.Metrics != nil {
  8717  		success := "false"
  8718  		if err == nil {
  8719  			success = "true"
  8720  		}
  8721  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.AnalyticsIncomingCount", success, elapsed)
  8722  	}
  8723  	return result, err
  8724  }
  8725  
  8726  func (s *TimerLayerWebhookStore) AnalyticsOutgoingCount(teamId string) (int64, error) {
  8727  	start := timemodule.Now()
  8728  
  8729  	result, err := s.WebhookStore.AnalyticsOutgoingCount(teamId)
  8730  
  8731  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8732  	if s.Root.Metrics != nil {
  8733  		success := "false"
  8734  		if err == nil {
  8735  			success = "true"
  8736  		}
  8737  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.AnalyticsOutgoingCount", success, elapsed)
  8738  	}
  8739  	return result, err
  8740  }
  8741  
  8742  func (s *TimerLayerWebhookStore) ClearCaches() {
  8743  	start := timemodule.Now()
  8744  
  8745  	s.WebhookStore.ClearCaches()
  8746  
  8747  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8748  	if s.Root.Metrics != nil {
  8749  		success := "false"
  8750  		if true {
  8751  			success = "true"
  8752  		}
  8753  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.ClearCaches", success, elapsed)
  8754  	}
  8755  }
  8756  
  8757  func (s *TimerLayerWebhookStore) DeleteIncoming(webhookId string, time int64) error {
  8758  	start := timemodule.Now()
  8759  
  8760  	err := s.WebhookStore.DeleteIncoming(webhookId, time)
  8761  
  8762  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8763  	if s.Root.Metrics != nil {
  8764  		success := "false"
  8765  		if err == nil {
  8766  			success = "true"
  8767  		}
  8768  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.DeleteIncoming", success, elapsed)
  8769  	}
  8770  	return err
  8771  }
  8772  
  8773  func (s *TimerLayerWebhookStore) DeleteOutgoing(webhookId string, time int64) error {
  8774  	start := timemodule.Now()
  8775  
  8776  	err := s.WebhookStore.DeleteOutgoing(webhookId, time)
  8777  
  8778  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8779  	if s.Root.Metrics != nil {
  8780  		success := "false"
  8781  		if err == nil {
  8782  			success = "true"
  8783  		}
  8784  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.DeleteOutgoing", success, elapsed)
  8785  	}
  8786  	return err
  8787  }
  8788  
  8789  func (s *TimerLayerWebhookStore) GetIncoming(id string, allowFromCache bool) (*model.IncomingWebhook, error) {
  8790  	start := timemodule.Now()
  8791  
  8792  	result, err := s.WebhookStore.GetIncoming(id, allowFromCache)
  8793  
  8794  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8795  	if s.Root.Metrics != nil {
  8796  		success := "false"
  8797  		if err == nil {
  8798  			success = "true"
  8799  		}
  8800  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetIncoming", success, elapsed)
  8801  	}
  8802  	return result, err
  8803  }
  8804  
  8805  func (s *TimerLayerWebhookStore) GetIncomingByChannel(channelId string) ([]*model.IncomingWebhook, error) {
  8806  	start := timemodule.Now()
  8807  
  8808  	result, err := s.WebhookStore.GetIncomingByChannel(channelId)
  8809  
  8810  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8811  	if s.Root.Metrics != nil {
  8812  		success := "false"
  8813  		if err == nil {
  8814  			success = "true"
  8815  		}
  8816  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetIncomingByChannel", success, elapsed)
  8817  	}
  8818  	return result, err
  8819  }
  8820  
  8821  func (s *TimerLayerWebhookStore) GetIncomingByTeam(teamId string, offset int, limit int) ([]*model.IncomingWebhook, error) {
  8822  	start := timemodule.Now()
  8823  
  8824  	result, err := s.WebhookStore.GetIncomingByTeam(teamId, offset, limit)
  8825  
  8826  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8827  	if s.Root.Metrics != nil {
  8828  		success := "false"
  8829  		if err == nil {
  8830  			success = "true"
  8831  		}
  8832  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetIncomingByTeam", success, elapsed)
  8833  	}
  8834  	return result, err
  8835  }
  8836  
  8837  func (s *TimerLayerWebhookStore) GetIncomingByTeamByUser(teamId string, userId string, offset int, limit int) ([]*model.IncomingWebhook, error) {
  8838  	start := timemodule.Now()
  8839  
  8840  	result, err := s.WebhookStore.GetIncomingByTeamByUser(teamId, userId, offset, limit)
  8841  
  8842  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8843  	if s.Root.Metrics != nil {
  8844  		success := "false"
  8845  		if err == nil {
  8846  			success = "true"
  8847  		}
  8848  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetIncomingByTeamByUser", success, elapsed)
  8849  	}
  8850  	return result, err
  8851  }
  8852  
  8853  func (s *TimerLayerWebhookStore) GetIncomingList(offset int, limit int) ([]*model.IncomingWebhook, error) {
  8854  	start := timemodule.Now()
  8855  
  8856  	result, err := s.WebhookStore.GetIncomingList(offset, limit)
  8857  
  8858  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8859  	if s.Root.Metrics != nil {
  8860  		success := "false"
  8861  		if err == nil {
  8862  			success = "true"
  8863  		}
  8864  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetIncomingList", success, elapsed)
  8865  	}
  8866  	return result, err
  8867  }
  8868  
  8869  func (s *TimerLayerWebhookStore) GetIncomingListByUser(userId string, offset int, limit int) ([]*model.IncomingWebhook, error) {
  8870  	start := timemodule.Now()
  8871  
  8872  	result, err := s.WebhookStore.GetIncomingListByUser(userId, offset, limit)
  8873  
  8874  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8875  	if s.Root.Metrics != nil {
  8876  		success := "false"
  8877  		if err == nil {
  8878  			success = "true"
  8879  		}
  8880  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetIncomingListByUser", success, elapsed)
  8881  	}
  8882  	return result, err
  8883  }
  8884  
  8885  func (s *TimerLayerWebhookStore) GetOutgoing(id string) (*model.OutgoingWebhook, error) {
  8886  	start := timemodule.Now()
  8887  
  8888  	result, err := s.WebhookStore.GetOutgoing(id)
  8889  
  8890  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8891  	if s.Root.Metrics != nil {
  8892  		success := "false"
  8893  		if err == nil {
  8894  			success = "true"
  8895  		}
  8896  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoing", success, elapsed)
  8897  	}
  8898  	return result, err
  8899  }
  8900  
  8901  func (s *TimerLayerWebhookStore) GetOutgoingByChannel(channelId string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
  8902  	start := timemodule.Now()
  8903  
  8904  	result, err := s.WebhookStore.GetOutgoingByChannel(channelId, offset, limit)
  8905  
  8906  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8907  	if s.Root.Metrics != nil {
  8908  		success := "false"
  8909  		if err == nil {
  8910  			success = "true"
  8911  		}
  8912  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoingByChannel", success, elapsed)
  8913  	}
  8914  	return result, err
  8915  }
  8916  
  8917  func (s *TimerLayerWebhookStore) GetOutgoingByChannelByUser(channelId string, userId string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
  8918  	start := timemodule.Now()
  8919  
  8920  	result, err := s.WebhookStore.GetOutgoingByChannelByUser(channelId, userId, offset, limit)
  8921  
  8922  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8923  	if s.Root.Metrics != nil {
  8924  		success := "false"
  8925  		if err == nil {
  8926  			success = "true"
  8927  		}
  8928  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoingByChannelByUser", success, elapsed)
  8929  	}
  8930  	return result, err
  8931  }
  8932  
  8933  func (s *TimerLayerWebhookStore) GetOutgoingByTeam(teamId string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
  8934  	start := timemodule.Now()
  8935  
  8936  	result, err := s.WebhookStore.GetOutgoingByTeam(teamId, offset, limit)
  8937  
  8938  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8939  	if s.Root.Metrics != nil {
  8940  		success := "false"
  8941  		if err == nil {
  8942  			success = "true"
  8943  		}
  8944  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoingByTeam", success, elapsed)
  8945  	}
  8946  	return result, err
  8947  }
  8948  
  8949  func (s *TimerLayerWebhookStore) GetOutgoingByTeamByUser(teamId string, userId string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
  8950  	start := timemodule.Now()
  8951  
  8952  	result, err := s.WebhookStore.GetOutgoingByTeamByUser(teamId, userId, offset, limit)
  8953  
  8954  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8955  	if s.Root.Metrics != nil {
  8956  		success := "false"
  8957  		if err == nil {
  8958  			success = "true"
  8959  		}
  8960  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoingByTeamByUser", success, elapsed)
  8961  	}
  8962  	return result, err
  8963  }
  8964  
  8965  func (s *TimerLayerWebhookStore) GetOutgoingList(offset int, limit int) ([]*model.OutgoingWebhook, error) {
  8966  	start := timemodule.Now()
  8967  
  8968  	result, err := s.WebhookStore.GetOutgoingList(offset, limit)
  8969  
  8970  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8971  	if s.Root.Metrics != nil {
  8972  		success := "false"
  8973  		if err == nil {
  8974  			success = "true"
  8975  		}
  8976  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoingList", success, elapsed)
  8977  	}
  8978  	return result, err
  8979  }
  8980  
  8981  func (s *TimerLayerWebhookStore) GetOutgoingListByUser(userId string, offset int, limit int) ([]*model.OutgoingWebhook, error) {
  8982  	start := timemodule.Now()
  8983  
  8984  	result, err := s.WebhookStore.GetOutgoingListByUser(userId, offset, limit)
  8985  
  8986  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  8987  	if s.Root.Metrics != nil {
  8988  		success := "false"
  8989  		if err == nil {
  8990  			success = "true"
  8991  		}
  8992  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.GetOutgoingListByUser", success, elapsed)
  8993  	}
  8994  	return result, err
  8995  }
  8996  
  8997  func (s *TimerLayerWebhookStore) InvalidateWebhookCache(webhook string) {
  8998  	start := timemodule.Now()
  8999  
  9000  	s.WebhookStore.InvalidateWebhookCache(webhook)
  9001  
  9002  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9003  	if s.Root.Metrics != nil {
  9004  		success := "false"
  9005  		if true {
  9006  			success = "true"
  9007  		}
  9008  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.InvalidateWebhookCache", success, elapsed)
  9009  	}
  9010  }
  9011  
  9012  func (s *TimerLayerWebhookStore) PermanentDeleteIncomingByChannel(channelId string) error {
  9013  	start := timemodule.Now()
  9014  
  9015  	err := s.WebhookStore.PermanentDeleteIncomingByChannel(channelId)
  9016  
  9017  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9018  	if s.Root.Metrics != nil {
  9019  		success := "false"
  9020  		if err == nil {
  9021  			success = "true"
  9022  		}
  9023  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.PermanentDeleteIncomingByChannel", success, elapsed)
  9024  	}
  9025  	return err
  9026  }
  9027  
  9028  func (s *TimerLayerWebhookStore) PermanentDeleteIncomingByUser(userId string) error {
  9029  	start := timemodule.Now()
  9030  
  9031  	err := s.WebhookStore.PermanentDeleteIncomingByUser(userId)
  9032  
  9033  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9034  	if s.Root.Metrics != nil {
  9035  		success := "false"
  9036  		if err == nil {
  9037  			success = "true"
  9038  		}
  9039  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.PermanentDeleteIncomingByUser", success, elapsed)
  9040  	}
  9041  	return err
  9042  }
  9043  
  9044  func (s *TimerLayerWebhookStore) PermanentDeleteOutgoingByChannel(channelId string) error {
  9045  	start := timemodule.Now()
  9046  
  9047  	err := s.WebhookStore.PermanentDeleteOutgoingByChannel(channelId)
  9048  
  9049  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9050  	if s.Root.Metrics != nil {
  9051  		success := "false"
  9052  		if err == nil {
  9053  			success = "true"
  9054  		}
  9055  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.PermanentDeleteOutgoingByChannel", success, elapsed)
  9056  	}
  9057  	return err
  9058  }
  9059  
  9060  func (s *TimerLayerWebhookStore) PermanentDeleteOutgoingByUser(userId string) error {
  9061  	start := timemodule.Now()
  9062  
  9063  	err := s.WebhookStore.PermanentDeleteOutgoingByUser(userId)
  9064  
  9065  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9066  	if s.Root.Metrics != nil {
  9067  		success := "false"
  9068  		if err == nil {
  9069  			success = "true"
  9070  		}
  9071  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.PermanentDeleteOutgoingByUser", success, elapsed)
  9072  	}
  9073  	return err
  9074  }
  9075  
  9076  func (s *TimerLayerWebhookStore) SaveIncoming(webhook *model.IncomingWebhook) (*model.IncomingWebhook, error) {
  9077  	start := timemodule.Now()
  9078  
  9079  	result, err := s.WebhookStore.SaveIncoming(webhook)
  9080  
  9081  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9082  	if s.Root.Metrics != nil {
  9083  		success := "false"
  9084  		if err == nil {
  9085  			success = "true"
  9086  		}
  9087  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.SaveIncoming", success, elapsed)
  9088  	}
  9089  	return result, err
  9090  }
  9091  
  9092  func (s *TimerLayerWebhookStore) SaveOutgoing(webhook *model.OutgoingWebhook) (*model.OutgoingWebhook, error) {
  9093  	start := timemodule.Now()
  9094  
  9095  	result, err := s.WebhookStore.SaveOutgoing(webhook)
  9096  
  9097  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9098  	if s.Root.Metrics != nil {
  9099  		success := "false"
  9100  		if err == nil {
  9101  			success = "true"
  9102  		}
  9103  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.SaveOutgoing", success, elapsed)
  9104  	}
  9105  	return result, err
  9106  }
  9107  
  9108  func (s *TimerLayerWebhookStore) UpdateIncoming(webhook *model.IncomingWebhook) (*model.IncomingWebhook, error) {
  9109  	start := timemodule.Now()
  9110  
  9111  	result, err := s.WebhookStore.UpdateIncoming(webhook)
  9112  
  9113  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9114  	if s.Root.Metrics != nil {
  9115  		success := "false"
  9116  		if err == nil {
  9117  			success = "true"
  9118  		}
  9119  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.UpdateIncoming", success, elapsed)
  9120  	}
  9121  	return result, err
  9122  }
  9123  
  9124  func (s *TimerLayerWebhookStore) UpdateOutgoing(hook *model.OutgoingWebhook) (*model.OutgoingWebhook, error) {
  9125  	start := timemodule.Now()
  9126  
  9127  	result, err := s.WebhookStore.UpdateOutgoing(hook)
  9128  
  9129  	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
  9130  	if s.Root.Metrics != nil {
  9131  		success := "false"
  9132  		if err == nil {
  9133  			success = "true"
  9134  		}
  9135  		s.Root.Metrics.ObserveStoreMethodDuration("WebhookStore.UpdateOutgoing", success, elapsed)
  9136  	}
  9137  	return result, err
  9138  }
  9139  
  9140  func (s *TimerLayer) Close() {
  9141  	s.Store.Close()
  9142  }
  9143  
  9144  func (s *TimerLayer) DropAllTables() {
  9145  	s.Store.DropAllTables()
  9146  }
  9147  
  9148  func (s *TimerLayer) GetCurrentSchemaVersion() string {
  9149  	return s.Store.GetCurrentSchemaVersion()
  9150  }
  9151  
  9152  func (s *TimerLayer) LockToMaster() {
  9153  	s.Store.LockToMaster()
  9154  }
  9155  
  9156  func (s *TimerLayer) MarkSystemRanUnitTests() {
  9157  	s.Store.MarkSystemRanUnitTests()
  9158  }
  9159  
  9160  func (s *TimerLayer) SetContext(context context.Context) {
  9161  	s.Store.SetContext(context)
  9162  }
  9163  
  9164  func (s *TimerLayer) TotalMasterDbConnections() int {
  9165  	return s.Store.TotalMasterDbConnections()
  9166  }
  9167  
  9168  func (s *TimerLayer) TotalReadDbConnections() int {
  9169  	return s.Store.TotalReadDbConnections()
  9170  }
  9171  
  9172  func (s *TimerLayer) TotalSearchDbConnections() int {
  9173  	return s.Store.TotalSearchDbConnections()
  9174  }
  9175  
  9176  func (s *TimerLayer) UnlockFromMaster() {
  9177  	s.Store.UnlockFromMaster()
  9178  }
  9179  
  9180  func New(childStore store.Store, metrics einterfaces.MetricsInterface) *TimerLayer {
  9181  	newStore := TimerLayer{
  9182  		Store:   childStore,
  9183  		Metrics: metrics,
  9184  	}
  9185  
  9186  	newStore.AuditStore = &TimerLayerAuditStore{AuditStore: childStore.Audit(), Root: &newStore}
  9187  	newStore.BotStore = &TimerLayerBotStore{BotStore: childStore.Bot(), Root: &newStore}
  9188  	newStore.ChannelStore = &TimerLayerChannelStore{ChannelStore: childStore.Channel(), Root: &newStore}
  9189  	newStore.ChannelMemberHistoryStore = &TimerLayerChannelMemberHistoryStore{ChannelMemberHistoryStore: childStore.ChannelMemberHistory(), Root: &newStore}
  9190  	newStore.ClusterDiscoveryStore = &TimerLayerClusterDiscoveryStore{ClusterDiscoveryStore: childStore.ClusterDiscovery(), Root: &newStore}
  9191  	newStore.CommandStore = &TimerLayerCommandStore{CommandStore: childStore.Command(), Root: &newStore}
  9192  	newStore.CommandWebhookStore = &TimerLayerCommandWebhookStore{CommandWebhookStore: childStore.CommandWebhook(), Root: &newStore}
  9193  	newStore.ComplianceStore = &TimerLayerComplianceStore{ComplianceStore: childStore.Compliance(), Root: &newStore}
  9194  	newStore.EmojiStore = &TimerLayerEmojiStore{EmojiStore: childStore.Emoji(), Root: &newStore}
  9195  	newStore.FileInfoStore = &TimerLayerFileInfoStore{FileInfoStore: childStore.FileInfo(), Root: &newStore}
  9196  	newStore.GroupStore = &TimerLayerGroupStore{GroupStore: childStore.Group(), Root: &newStore}
  9197  	newStore.JobStore = &TimerLayerJobStore{JobStore: childStore.Job(), Root: &newStore}
  9198  	newStore.LicenseStore = &TimerLayerLicenseStore{LicenseStore: childStore.License(), Root: &newStore}
  9199  	newStore.LinkMetadataStore = &TimerLayerLinkMetadataStore{LinkMetadataStore: childStore.LinkMetadata(), Root: &newStore}
  9200  	newStore.OAuthStore = &TimerLayerOAuthStore{OAuthStore: childStore.OAuth(), Root: &newStore}
  9201  	newStore.PluginStore = &TimerLayerPluginStore{PluginStore: childStore.Plugin(), Root: &newStore}
  9202  	newStore.PostStore = &TimerLayerPostStore{PostStore: childStore.Post(), Root: &newStore}
  9203  	newStore.PreferenceStore = &TimerLayerPreferenceStore{PreferenceStore: childStore.Preference(), Root: &newStore}
  9204  	newStore.ProductNoticesStore = &TimerLayerProductNoticesStore{ProductNoticesStore: childStore.ProductNotices(), Root: &newStore}
  9205  	newStore.ReactionStore = &TimerLayerReactionStore{ReactionStore: childStore.Reaction(), Root: &newStore}
  9206  	newStore.RoleStore = &TimerLayerRoleStore{RoleStore: childStore.Role(), Root: &newStore}
  9207  	newStore.SchemeStore = &TimerLayerSchemeStore{SchemeStore: childStore.Scheme(), Root: &newStore}
  9208  	newStore.SessionStore = &TimerLayerSessionStore{SessionStore: childStore.Session(), Root: &newStore}
  9209  	newStore.StatusStore = &TimerLayerStatusStore{StatusStore: childStore.Status(), Root: &newStore}
  9210  	newStore.SystemStore = &TimerLayerSystemStore{SystemStore: childStore.System(), Root: &newStore}
  9211  	newStore.TeamStore = &TimerLayerTeamStore{TeamStore: childStore.Team(), Root: &newStore}
  9212  	newStore.TermsOfServiceStore = &TimerLayerTermsOfServiceStore{TermsOfServiceStore: childStore.TermsOfService(), Root: &newStore}
  9213  	newStore.ThreadStore = &TimerLayerThreadStore{ThreadStore: childStore.Thread(), Root: &newStore}
  9214  	newStore.TokenStore = &TimerLayerTokenStore{TokenStore: childStore.Token(), Root: &newStore}
  9215  	newStore.UploadSessionStore = &TimerLayerUploadSessionStore{UploadSessionStore: childStore.UploadSession(), Root: &newStore}
  9216  	newStore.UserStore = &TimerLayerUserStore{UserStore: childStore.User(), Root: &newStore}
  9217  	newStore.UserAccessTokenStore = &TimerLayerUserAccessTokenStore{UserAccessTokenStore: childStore.UserAccessToken(), Root: &newStore}
  9218  	newStore.UserTermsOfServiceStore = &TimerLayerUserTermsOfServiceStore{UserTermsOfServiceStore: childStore.UserTermsOfService(), Root: &newStore}
  9219  	newStore.WebhookStore = &TimerLayerWebhookStore{WebhookStore: childStore.Webhook(), Root: &newStore}
  9220  	return &newStore
  9221  }