Add new Metrics API (#26919)

server/public/model/client4.go

@@ -588,6 +588,10 @@ func (c *Client4) bookmarkRoute(channelId, bookmarkId string) string {
 	return fmt.Sprintf(c.bookmarksRoute(channelId)+"/%v", bookmarkId)
 }
 
+func (c *Client4) perfMetricsRoute() string {
+	return "/perf"
+}
+
 func (c *Client4) DoAPIGet(ctx context.Context, url string, etag string) (*http.Response, error) {
 	return c.DoAPIRequest(ctx, http.MethodGet, c.APIURL+url, "", etag)
 }
@@ -8848,3 +8852,16 @@ func (c *Client4) ListChannelBookmarksForChannel(ctx context.Context, channelId
 	}
 	return b, BuildResponse(r), nil
 }
+
+func (c *Client4) SubmitClientMetrics(ctx context.Context, report *PerformanceReport) (*Response, error) {
+	buf, err := json.Marshal(report)
+	if err != nil {
+		return nil, NewAppError("SubmitClientMetrics", "api.marshal_error", nil, "", http.StatusInternalServerError).Wrap(err)
+	}
+	res, err := c.DoAPIPostBytes(ctx, c.perfMetricsRoute(), buf)
+	if err != nil {
+		return BuildResponse(res), err
+	}
+
+	return BuildResponse(res), nil
+}

server/public/model/metrics.go

@@ -0,0 +1,114 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/blang/semver/v4"
+)
+
+type MetricType string
+
+const (
+	ClientTimeToFirstByte        MetricType = "TTFB"
+	ClientFirstContentfulPaint   MetricType = "FCP"
+	ClientLargestContentfulPaint MetricType = "LCP"
+	ClientInteractionToNextPaint MetricType = "INP"
+	ClientCumulativeLayoutShift  MetricType = "CLS"
+	ClientLongTasks              MetricType = "long_tasks"
+	ClientChannelSwitchDuration  MetricType = "channel_switch"
+	ClientTeamSwitchDuration     MetricType = "team_switch"
+	ClientRHSLoadDuration        MetricType = "rhs_load"
+
+	performanceReportTTLMilliseconds = 300 * 1000 // 300 seconds/5 minutes
+)
+
+var (
+	performanceReportVersion = semver.MustParse("0.1.0")
+	acceptedPlatforms        = sliceToMapKey("linux", "macos", "ios", "android", "windows", "other")
+	acceptedAgents           = sliceToMapKey("desktop", "firefox", "chrome", "safari", "edge", "other")
+)
+
+type MetricSample struct {
+	Metric    MetricType        `json:"metric"`
+	Value     int64             `json:"value"`
+	Timestamp int64             `json:"timestamp,omitempty"`
+	Labels    map[string]string `json:"labels,omitempty"`
+}
+
+// PerformanceReport is a set of samples collected from a client
+type PerformanceReport struct {
+	Version    string            `json:"version"`
+	ClientID   string            `json:"client_id"`
+	Labels     map[string]string `json:"labels"`
+	Start      int64             `json:"start"`
+	End        int64             `json:"end"`
+	Counters   []*MetricSample   `json:"counters"`
+	Histograms []*MetricSample   `json:"histograms"`
+}
+
+func (r *PerformanceReport) IsValid() error {
+	if r == nil {
+		return fmt.Errorf("the report is nil")
+	}
+
+	reportVersion, err := semver.ParseTolerant(r.Version)
+	if err != nil {
+		return err
+	}
+
+	if reportVersion.Major != performanceReportVersion.Major || reportVersion.Minor > performanceReportVersion.Minor {
+		return fmt.Errorf("report version is not supported: server version: %s, report version: %s", performanceReportVersion.String(), r.Version)
+	}
+
+	if r.Start >= r.End {
+		return fmt.Errorf("report timestamps are erroneous")
+	}
+
+	now := time.Now().UnixMilli()
+	if r.End < now-performanceReportTTLMilliseconds {
+		return fmt.Errorf("report is outdated: %d", r.End)
+	}
+
+	return nil
+}
+
+func (r *PerformanceReport) ProcessLabels() map[string]string {
+	var platform, agent string
+	var ok bool
+
+	// check if the platform is specified
+	platform, ok = r.Labels["platform"]
+	if !ok {
+		platform = "other"
+	}
+	platform = strings.ToLower(platform)
+
+	// check if platform is one of the accepted platforms
+	_, ok = acceptedPlatforms[platform]
+	if !ok {
+		platform = "other"
+	}
+
+	// check if the agent is specified
+	agent, ok = r.Labels["agent"]
+	if !ok {
+		agent = "other"
+	}
+	agent = strings.ToLower(agent)
+
+	// check if agent is one of the accepted agents
+	_, ok = acceptedAgents[agent]
+	if !ok {
+		agent = "other"
+	}
+
+	return map[string]string{
+		"platform": platform,
+		"agent":    agent,
+	}
+}

server/public/model/metrics_test.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPerformanceReport_IsValid(t *testing.T) {
+	outdatedTimestamp := time.Now().Add(-6 * time.Minute).UnixMilli()
+	tests := []struct {
+		name     string
+		report   *PerformanceReport
+		expected error
+	}{
+		{
+			name: "ValidReport",
+			report: &PerformanceReport{
+				Version: "0.1.0",
+				Labels:  map[string]string{"platform": "linux"},
+				Start:   time.Now().UnixMilli() - 10000,
+				End:     time.Now().UnixMilli(),
+			},
+			expected: nil,
+		},
+		{
+			name:     "NilReport",
+			report:   nil,
+			expected: fmt.Errorf("the report is nil"),
+		},
+		{
+			name: "UnsupportedVersion",
+			report: &PerformanceReport{
+				Version: "2.0.0",
+				Labels:  map[string]string{"platform": "linux"},
+				Start:   time.Now().UnixMilli() - 10000,
+				End:     time.Now().UnixMilli(),
+			},
+			expected: fmt.Errorf("report version is not supported: server version: 0.1.0, report version: 2.0.0"),
+		},
+		{
+			name: "ErroneousTimestamps",
+			report: &PerformanceReport{
+				Version: "0.1.0",
+				Labels:  map[string]string{"platform": "linux"},
+				Start:   time.Now().UnixMilli(),
+				End:     time.Now().Add(-1 * time.Hour).UnixMilli(),
+			},
+			expected: fmt.Errorf("report timestamps are erroneous"),
+		},
+		{
+			name: "OutdatedReport",
+			report: &PerformanceReport{
+				Version: "0.1.0",
+				Labels:  map[string]string{"platform": "linux"},
+				Start:   time.Now().Add(-7 * time.Minute).UnixMilli(),
+				End:     outdatedTimestamp,
+			},
+			expected: fmt.Errorf("report is outdated: %d", outdatedTimestamp),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.report.IsValid()
+			if tt.expected != nil {
+				require.EqualError(t, err, tt.expected.Error())
+				return
+			}
+			require.NoError(t, err)
+		})
+	}
+}

server/public/model/utils.go

@@ -844,3 +844,16 @@ func filterBlocklist(r rune) rune {
 func IsCloud() bool {
 	return os.Getenv("MM_CLOUD_INSTALLATION_ID") != ""
 }
+
+func sliceToMapKey(s ...string) map[string]any {
+	m := make(map[string]any)
+	for i := range s {
+		m[s[i]] = struct{}{}
+	}
+
+	if len(s) != len(m) {
+		panic("duplicate keys")
+	}
+
+	return m
+}