Add client metrics

.golangci.yml

@@ -6,7 +6,6 @@ linters-settings:
   gofmt:
     simplify: true
   govet:
-    check-shadowing: false # set this to true from time to time to check for possible issues
     disable-all: true
     enable:
       - asmdecl      # report mismatches between assembly files and Go declarations
@@ -36,19 +35,10 @@ linters:
   disable-all: true
   enable:
     - gofmt         # Checks whether code was gofmt-ed
-    - golint        # Differs from gofmt. Gofmt reformats Go source code, whereas golint prints out style mistakes
+    # - revive      # Needs a review of rules https://mattermost.atlassian.net/browse/MM-58690
     - gosimple      # Linter for Go source code that specializes in simplifying a code
     - govet         # Examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string
     - ineffassign   # Detects when assignments to existing variables are not used
     - unconvert     # Removes unnecessary type conversions
     - unused        # Checks Go code for unused constants, variables, functions and types
     - exportloopref # Checks for pointers to enclosing loop variables
-
-issues:
-  exclude-rules:
-    - linters:
-      # Used to avoid errors regarding naming conventions
-      # We can remove this section once we decide to fix them
-      - golint
-      text: "should be.*ID|CamelCase$|FileJSON`$|ConsoleJSON`$|APIURL`$|calling this Response$"
-

loadtest/control/simulcontroller/actions.go

@@ -67,6 +67,8 @@ func (c *SimulController) disconnect() error {
 }
 
 func (c *SimulController) reload(full bool) control.UserActionResponse {
+	start := time.Now()
+
 	if full {
 		if err := c.disconnect(); err != nil {
 			return control.UserActionResponse{Err: control.NewUserError(err)}
@@ -80,6 +82,14 @@ func (c *SimulController) reload(full bool) control.UserActionResponse {
 		}
 	}
 
+	defer func() {
+		elapsed := time.Since(start).Seconds()
+		err := c.user.ObserveClientMetric(model.ClientPageLoadDuration, elapsed)
+		if err != nil {
+			mlog.Warn("Failed to store observation", mlog.Err(err))
+		}
+	}()
+
 	// A full reload always calls GET /api/v4/users?page=0&per_page=100,
 	// regardless of GraphQL enabled or not
 	_, err := c.user.GetUsers(0, 100)
@@ -139,11 +149,17 @@ func (c *SimulController) loginOrSignUp(u user.User) control.UserActionResponse
 }
 
 func (c *SimulController) login(u user.User) control.UserActionResponse {
+	start := time.Now()
 	for {
 		resp := control.Login(u)
 		if resp.Err == nil {
 			err := c.connect()
 			if err == nil {
+				elapsed := time.Since(start).Seconds()
+				err := c.user.ObserveClientMetric(model.ClientTimeToFirstByte, elapsed)
+				if err != nil {
+					mlog.Warn("Failed to store observation", mlog.Err(err))
+				}
 				return resp
 			}
 			c.status <- c.newErrorStatus(err)
@@ -280,12 +296,20 @@ func loadTeam(u user.User, team *model.Team, gqlEnabled bool) control.UserAction
 }
 
 func (c *SimulController) switchTeam(u user.User) control.UserActionResponse {
+	start := time.Now()
 	team, err := u.Store().RandomTeam(store.SelectMemberOf | store.SelectNotCurrent)
 	if errors.Is(err, memstore.ErrTeamStoreEmpty) {
 		return control.UserActionResponse{Info: "no other team to switch to"}
 	} else if err != nil {
 		return control.UserActionResponse{Err: control.NewUserError(err)}
 	}
+	defer func() {
+		elapsed := time.Since(start).Seconds()
+		err := c.user.ObserveClientMetric(model.ClientTeamSwitchDuration, elapsed)
+		if err != nil {
+			mlog.Warn("Failed to store observation", mlog.Err(err))
+		}
+	}()
 
 	c.status <- c.newInfoStatus(fmt.Sprintf("switched to team %s", team.Id))
 
@@ -434,6 +458,7 @@ func fetchPostsInfo(u user.User, postsIds []string) error {
 }
 
 func viewChannel(u user.User, channel *model.Channel) control.UserActionResponse {
+	start := time.Now()
 	collapsedThreads, resp := control.CollapsedThreadsEnabled(u)
 	if resp.Err != nil {
 		return resp
@@ -477,6 +502,13 @@ func viewChannel(u user.User, channel *model.Channel) control.UserActionResponse
 	// frequencies are also calculated that way.
 	// This is a good enough approximation.
 	if rand.Float64() < 0.01 {
+		defer func() {
+			elapsed := time.Since(start).Seconds()
+			err := u.ObserveClientMetric(model.ClientRHSLoadDuration, elapsed)
+			if err != nil {
+				mlog.Warn("Failed to store observation", mlog.Err(err))
+			}
+		}()
 		excludeFileCount = false
 	}
 
@@ -520,6 +552,7 @@ func viewChannel(u user.User, channel *model.Channel) control.UserActionResponse
 }
 
 func switchChannel(u user.User) control.UserActionResponse {
+	start := time.Now()
 	team, err := u.Store().CurrentTeam()
 	if err != nil {
 		return control.UserActionResponse{Err: control.NewUserError(err)}
@@ -535,6 +568,13 @@ func switchChannel(u user.User) control.UserActionResponse {
 	if resp := viewChannel(u, &channel); resp.Err != nil {
 		return control.UserActionResponse{Err: control.NewUserError(resp.Err)}
 	}
+	defer func() {
+		elapsed := time.Since(start).Seconds()
+		err := u.ObserveClientMetric(model.ClientChannelSwitchDuration, elapsed)
+		if err != nil {
+			mlog.Warn("Failed to store observation", mlog.Err(err))
+		}
+	}()
 
 	if err := u.SetCurrentChannel(&channel); err != nil {
 		return control.UserActionResponse{Err: control.NewUserError(err)}
@@ -1472,6 +1512,7 @@ func sendTypingEventIfEnabled(u user.User, channelId string) error {
 }
 
 func (c *SimulController) viewGlobalThreads(u user.User) control.UserActionResponse {
+	start := time.Now()
 	collapsedThreads, resp := control.CollapsedThreadsEnabled(u)
 	if resp.Err != nil || !collapsedThreads {
 		return resp
@@ -1505,6 +1546,14 @@ func (c *SimulController) viewGlobalThreads(u user.User) control.UserActionRespo
 		}
 	}
 
+	defer func() {
+		elapsed := time.Since(start).Seconds()
+		err := c.user.ObserveClientMetric(model.ClientGlobalThreadsLoadDuration, elapsed)
+		if err != nil {
+			mlog.Warn("Failed to store observation", mlog.Err(err))
+		}
+	}()
+
 	oldestThreadId := threads[len(threads)-1].PostId
 	// scrolling between 1 and 3 times
 	numScrolls := rand.Intn(3) + 1
@@ -2154,3 +2203,12 @@ func (c *SimulController) generateUserReport(u user.User) control.UserActionResp
 
 	return control.UserActionResponse{Info: fmt.Sprintf("generated user report for %d users", totalUsers)}
 }
+
+func submitPerformanceReport(u user.User) control.UserActionResponse {
+	err := u.SubmitPerformanceReport()
+	if err != nil {
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	return control.UserActionResponse{Info: "submitted client performance report"}
+}

loadtest/control/simulcontroller/periodic.go

@@ -10,19 +10,33 @@ import (
 
 const (
 	getUsersStatusByIdsInterval = 60 * time.Second
+	submitClientMetircsInterval = 60 * time.Second
 )
 
 func (c *SimulController) periodicActions(wg *sync.WaitGroup) {
-	defer wg.Done()
+	st := time.NewTicker(getUsersStatusByIdsInterval)
+	mt := time.NewTicker(submitClientMetircsInterval)
+
+	defer func() {
+		mt.Stop()
+		st.Stop()
+		wg.Done()
+	}()
+
 	for {
 		select {
-		case <-time.After(getUsersStatusByIdsInterval):
+		case <-st.C:
 			if resp := c.getUsersStatuses(); resp.Err != nil {
 				c.status <- c.newErrorStatus(resp.Err)
 			} else {
 				c.status <- c.newInfoStatus(resp.Info)
 			}
-		// We can add more periodic actions here.
+		case <-mt.C:
+			if resp := submitPerformanceReport(c.user); resp.Err != nil {
+				c.status <- c.newErrorStatus(resp.Err)
+			} else {
+				c.status <- c.newInfoStatus(resp.Info)
+			}
 		case <-c.disconnectChan:
 			return
 		}

loadtest/store/memstore/store.go

@@ -49,6 +49,7 @@ type MemStore struct {
 	threadsQueue        *CQueue[model.ThreadResponse]
 	sidebarCategories   map[string]map[string]*model.SidebarCategoryWithChannels
 	featureFlags        map[string]bool
+	report              *model.PerformanceReport
 }
 
 // New returns a new instance of MemStore with the given config.
@@ -125,6 +126,7 @@ func (s *MemStore) Clear() {
 	s.threadsQueue.Reset()
 	clearMap(s.sidebarCategories)
 	s.sidebarCategories = map[string]map[string]*model.SidebarCategoryWithChannels{}
+	s.report = &model.PerformanceReport{}
 }
 
 func (s *MemStore) setupQueues(config *Config) error {
@@ -1185,3 +1187,58 @@ func (s *MemStore) PostsWithAckRequests() ([]string, error) {
 
 	return ids, nil
 }
+
+func (s *MemStore) SetPerformanceReport(report *model.PerformanceReport) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.report = report
+}
+
+func (s *MemStore) PerformanceReport() (*model.PerformanceReport, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+	if s.report == nil {
+		return nil, nil
+	}
+
+	report := &model.PerformanceReport{
+		Version:  s.report.Version,
+		ClientID: s.report.ClientID,
+		Start:    s.report.Start,
+		End:      s.report.End,
+	}
+
+	if s.report.Labels != nil {
+		report.Labels = make(map[string]string)
+	}
+	for k, v := range s.report.Labels {
+		report.Labels[k] = v
+	}
+
+	if s.report.Histograms != nil {
+		report.Histograms = make([]*model.MetricSample, len(s.report.Histograms))
+	}
+	for i, h := range s.report.Histograms {
+		report.Histograms[i] = &model.MetricSample{
+			Metric:    h.Metric,
+			Value:     h.Value,
+			Timestamp: h.Timestamp,
+			Labels:    h.Labels,
+		}
+	}
+
+	if s.report.Counters != nil {
+		report.Counters = make([]*model.MetricSample, len(s.report.Counters))
+	}
+	for i, h := range s.report.Counters {
+		report.Counters[i] = &model.MetricSample{
+			Metric:    h.Metric,
+			Value:     h.Value,
+			Timestamp: h.Timestamp,
+			Labels:    h.Labels,
+		}
+	}
+
+	return report, nil
+}

loadtest/store/store.go

@@ -144,6 +144,9 @@ type UserStore interface {
 
 	// PostsWithAckRequests returns IDs of the posts that asked for acknowledgment.
 	PostsWithAckRequests() ([]string, error)
+
+	// PerformanceReport returns a copy of underlying performance report
+	PerformanceReport() (*model.PerformanceReport, error)
 }
 
 // MutableUserStore is a super-set of UserStore which, apart from providing
@@ -252,4 +255,7 @@ type MutableUserStore interface {
 
 	// SidebarCategories
 	SetCategories(teamID string, sidebarCategories *model.OrderedSidebarCategories) error
+
+	// ClientPerformance
+	SetPerformanceReport(report *model.PerformanceReport)
 }

loadtest/user/user.go

@@ -317,4 +317,8 @@ type User interface {
 	// GraphQL
 	GetInitialDataGQL() error
 	GetChannelsAndChannelMembersGQL(teamID string, includeDeleted bool, channelsCursor, channelMembersCursor string) (string, string, error)
+
+	// Client Metrics
+	ObserveClientMetric(t model.MetricType, v float64) error
+	SubmitPerformanceReport() error
 }

loadtest/user/userentity/report.go

@@ -0,0 +1,68 @@
+package userentity
+
+import (
+	"context"
+	"math/rand"
+	"time"
+
+	"github.com/mattermost/mattermost/server/public/model"
+)
+
+var (
+	userAgents = []string{"desktop", "firefox", "chrome", "safari", "edge", "other"}
+	platforms  = []string{"linux", "macos", "ios", "android", "windows", "other"}
+)
+
+func (ue *UserEntity) ObserveClientMetric(t model.MetricType, v float64) error {
+	report, err := ue.store.PerformanceReport()
+	if err != nil {
+		return err
+	}
+	defer ue.store.SetPerformanceReport(report)
+
+	switch t {
+	case model.ClientTimeToFirstByte, model.ClientFirstContentfulPaint, model.ClientLargestContentfulPaint,
+		model.ClientInteractionToNextPaint, model.ClientCumulativeLayoutShift, model.ClientChannelSwitchDuration,
+		model.ClientTeamSwitchDuration, model.ClientRHSLoadDuration:
+		if report.Histograms == nil {
+			report.Histograms = make([]*model.MetricSample, 0)
+		}
+
+		report.Histograms = append(report.Histograms, &model.MetricSample{
+			Metric:    t,
+			Value:     v,
+			Timestamp: float64(time.Now().UnixMilli()) / 1000,
+		})
+	default:
+		// server also ignores the unkown typed metrics
+	}
+	return nil
+}
+
+func (ue *UserEntity) SubmitPerformanceReport() error {
+	report, err := ue.store.PerformanceReport()
+	if err != nil {
+		return err
+	}
+	report.End = float64(time.Now().UnixMilli() / 1000)
+
+	_, err = ue.client.SubmitClientMetrics(context.Background(), report)
+	if err != nil {
+		return err
+	}
+	ue.store.SetPerformanceReport(&model.PerformanceReport{
+		Start: float64(time.Now().UnixMilli() / 1000),
+	})
+
+	return nil
+}
+
+func randomUserAgent() string {
+	i := rand.Intn(len(userAgents))
+	return userAgents[i]
+}
+
+func randomPlatform() string {
+	i := rand.Intn(len(platforms))
+	return platforms[i]
+}

loadtest/user/userentity/user.go

@@ -147,6 +147,15 @@ func New(setup Setup, config Config) *UserEntity {
 	if err != nil {
 		return nil
 	}
+	ue.store.SetPerformanceReport(&model.PerformanceReport{
+		Version: "0.1.0",
+		Labels: map[string]string{
+			"platform": randomPlatform(),
+			"agent":    randomUserAgent(),
+		},
+		ClientID: model.NewId(),
+		Start:    float64(time.Now().UnixMilli() / 1000),
+	})
 
 	return &ue
 }