snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

tools/mattermost-govet/configtelemetry/telemetry.go

@@ -0,0 +1,129 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package configtelemetry
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/types"
+	"reflect"
+	"strings"
+
+	"github.com/mattermost/mattermost/tools/mattermost-govet/util"
+	"golang.org/x/tools/go/analysis"
+)
+
+var (
+	telemetryPkgPath = util.ServerModulePath + "/platform/telemetry"
+	modelPkgPath     = util.ModelPkgPath
+)
+
+const (
+	configStructName = "Config"
+	telemetryPkgName = "telemetry"
+)
+
+// Analyzer reports config fields where telemetry is not sent
+var Analyzer = &analysis.Analyzer{
+	Name:       "configtelemetry",
+	Doc:        "reports config fields where telemetry is not sent (unless it is specifically indicated  that no telemetry will be sent for that field)",
+	Run:        run,
+	ResultType: reflect.TypeOf(&analysis.Pass{}),
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	if pass.Pkg.Path() != telemetryPkgPath {
+		return pass, nil
+	}
+
+	// we need to find model.Config definition to parse its Type Spec
+	var configObject *types.TypeName
+	for _, obj := range pass.TypesInfo.Uses {
+		if tn, ok := obj.(*types.TypeName); ok && obj.Name() == configStructName && obj.Pkg().Path() == modelPkgPath {
+			configObject = tn
+			break
+		}
+	}
+
+	if configObject == nil {
+		return pass, errors.New("could not find model.Config type")
+	}
+
+	if !configObject.Pos().IsValid() {
+		return pass, errors.New("model.Config position is not valid")
+	}
+
+	srcFile := pass.Fset.PositionFor(configObject.Pos(), false).Filename
+	file, err := parser.ParseFile(pass.Fset, srcFile, nil, parser.AllErrors|parser.ParseComments)
+	if err != nil {
+		return pass, fmt.Errorf("could parse file %q: %w", srcFile, err)
+	}
+
+	pass.Files = append(pass.Files, file)
+
+	configMap, err := typeFieldMap(file, configObject.Name())
+	if err != nil {
+		return pass, fmt.Errorf("could generate fields map: %w", err)
+	}
+
+	var allExpressions []string
+
+	// We look at every expression in the file so that we can
+	// check if the expected references exist in this package.
+
+	// NOTE: this approach does not check if the reference (config field) is added
+	// to telemetry queue, it assumes that if a config field is used in the file,
+	// it probably added to the telemetry. This is a naive approach but should work.
+	// Also, we can narrow down this for specific function calls, declarations etc.
+	// so that we can be sure if the config field is added to telemetry but all these
+	// fine tuning will require extra maintenance cost and yet, it is still possible to
+	// trick the checker. Hence, it is decided to go with this broader check. This check
+	// can be considered as a reminder to developers when they forget to add a field to
+	// telemetry. Fortunately, further verification can be done at code reviews.
+	for _, file := range pass.Files {
+		if file.Name.Name != telemetryPkgName {
+			continue
+		}
+
+		ast.Inspect(file, func(n ast.Node) bool {
+			expr, ok := n.(ast.Expr)
+			if !ok {
+				return true
+			}
+
+			sel, ok := expr.(*ast.SelectorExpr)
+			if !ok {
+				return true
+			}
+
+			allExpressions = append(allExpressions, getFieldAccessSequence(sel))
+			return true
+		})
+	}
+
+	// now remove the expresions from what's expected
+	for _, ref := range allExpressions {
+		delete(configMap, ref)
+	}
+
+	// report remaining fields from the map
+	for k, v := range configMap {
+		pass.Reportf(v, "%v is not used in telemetry", k)
+	}
+
+	return pass, nil
+}
+
+// getFieldAccessSequence is used recursively to get string representation of
+// a selector expression sequence. e.g. config.ServiceSettings.SiteURL
+func getFieldAccessSequence(sel *ast.SelectorExpr) string {
+	switch v := sel.X.(type) {
+	case *ast.SelectorExpr:
+		return strings.Join([]string{getFieldAccessSequence(v), sel.Sel.Name}, ".")
+	default:
+		return sel.Sel.Name
+	}
+}

tools/mattermost-govet/configtelemetry/telemetry_test.go

@@ -0,0 +1,81 @@
+package configtelemetry
+
+import (
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/analysis/analysistest"
+)
+
+// stubT is a minimal testing.T implementation that doesn't fail
+// Used to capture analysistest results without test failures
+type stubT struct {
+	testing.TB
+}
+
+func (s *stubT) Errorf(format string, args ...any) {
+	// Ignore errors from analysistest about unexpected diagnostics
+	// We validate diagnostics manually below
+}
+
+func Test(t *testing.T) {
+	telemetryPkgPath = "telemetry"
+	modelPkgPath = "model"
+	testdata := analysistest.TestData()
+
+	// Run analyzer using a stub to prevent analysistest from failing on cross-package diagnostics
+	// (diagnostics are reported on model package from telemetry package analysis)
+	stub := &stubT{TB: t}
+	results := analysistest.Run(stub, testdata, Analyzer, "telemetry")
+
+	// Manually verify expected diagnostics
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+
+	result := results[0]
+	if len(result.Diagnostics) == 0 {
+		t.Fatal("expected diagnostics but got none")
+	}
+
+	// Expected diagnostics: fields in model/config.go that are NOT used in telemetry
+	expectedDiagnostics := map[string]bool{
+		"ServiceSettings.WebsocketURL is not used in telemetry":                                false,
+		"ServiceSettings.LicenseFileLocation is not used in telemetry":                         false,
+		"MessageExportSettings.GlobalRelaySettings.SMTPServerTimeout is not used in telemetry": false,
+		"CloudSettings.CWSUrl is not used in telemetry":                                        false,
+	}
+
+	// Check that we got all expected diagnostics
+	for _, diag := range result.Diagnostics {
+		msg := diag.Message
+		if _, ok := expectedDiagnostics[msg]; ok {
+			expectedDiagnostics[msg] = true
+			// Verify diagnostic is in model/config.go
+			pos := result.Pass.Fset.Position(diag.Pos)
+			if !strings.Contains(pos.Filename, "model/config.go") {
+				t.Errorf("diagnostic %q should be in model/config.go, got %s", msg, pos.Filename)
+			}
+		}
+	}
+
+	// Verify all expected diagnostics were found
+	for msg, found := range expectedDiagnostics {
+		if !found {
+			t.Errorf("expected diagnostic not found: %s", msg)
+		}
+	}
+
+	// Verify we don't have unexpected diagnostics
+	if len(result.Diagnostics) != len(expectedDiagnostics) {
+		var unexpectedMsgs []string
+		for _, diag := range result.Diagnostics {
+			if _, ok := expectedDiagnostics[diag.Message]; !ok {
+				unexpectedMsgs = append(unexpectedMsgs, diag.Message)
+			}
+		}
+		if len(unexpectedMsgs) > 0 {
+			t.Errorf("got %d unexpected diagnostics: %v", len(unexpectedMsgs), unexpectedMsgs)
+		}
+	}
+}

tools/mattermost-govet/configtelemetry/testdata/src/model/config.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+const (
+	SERVICE_SETTINGS_DEFAULT_SITE_URL = "http://localhost:8065"
+)
+
+type ServiceSettings struct {
+	SiteURL                  *string  `access:"environment,authentication,write_restrictable"`
+	WebsocketURL             *string  `access:"write_restrictable,cloud_restrictable"`
+	LicenseFileLocation      *string  `access:"write_restrictable,cloud_restrictable"`
+	ListenAddress            *string  `access:"environment,write_restrictable,cloud_restrictable"` // telemetry: none
+	TLSStrictTransport       *bool    `access:"write_restrictable,cloud_restrictable"`
+	TLSStrictTransportMaxAge *int64   `access:"write_restrictable,cloud_restrictable"` // telemetry: none
+	TLSOverwriteCiphers      []string `access:"write_restrictable,cloud_restrictable"`
+	TrustedProxyIPHeader     []string `access:"write_restrictable,cloud_restrictable"` // telemetry: none
+
+}
+
+type GlobalRelayMessageExportSettings struct {
+	CustomerType      *string `access:"compliance"` // must be either A9 or A10, dictates SMTP server url
+	SmtpUsername      string  `access:"compliance"`
+	SMTPServerTimeout *int    `access:"compliance"`
+}
+
+type MessageExportSettings struct {
+	ExportFromTimestamp *int64 `access:"compliance"`
+	BatchSize           *int   `access:"compliance"`
+
+	// formatter-specific settings - these are only expected to be non-nil if ExportFormat is set to the associated format
+	GlobalRelaySettings *GlobalRelayMessageExportSettings `access:"compliance"`
+}
+
+type CloudSettings struct {
+	CWSUrl *string `access:"environment,write_restrictable"`
+}
+
+type Config struct {
+	ServiceSettings       ServiceSettings
+	MessageExportSettings MessageExportSettings
+	CloudSettings         CloudSettings
+}

tools/mattermost-govet/configtelemetry/testdata/src/telemetry/telemetry.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package telemetry
+
+import (
+	"model"
+)
+
+const (
+	TrackConfigService       = "config_service"
+	TrackConfigMessageExport = "config_message_export"
+)
+
+type ServerIface interface {
+	Config() *model.Config
+}
+
+type TelemetryService struct {
+	srv ServerIface
+}
+
+func (ts *TelemetryService) sendTelemetry(event string, properties map[string]interface{}) {
+}
+
+func isDefault(setting interface{}, defaultValue interface{}) bool {
+	return setting == defaultValue
+}
+
+func (ts *TelemetryService) trackConfig() {
+	cfg := ts.srv.Config()
+	ts.sendTelemetry(TrackConfigService, map[string]interface{}{
+		"tls_strict_transport":  *cfg.ServiceSettings.TLSStrictTransport,
+		"tls_overwrite_ciphers": len(cfg.ServiceSettings.TLSOverwriteCiphers),
+		"isdefault_site_url":    isDefault(*cfg.ServiceSettings.SiteURL, model.SERVICE_SETTINGS_DEFAULT_SITE_URL),
+	})
+
+	ts.sendTelemetry(TrackConfigMessageExport, map[string]interface{}{
+		"default_export_from_timestamp":         *cfg.MessageExportSettings.ExportFromTimestamp + 1,
+		"batch_size":                            (*cfg.MessageExportSettings.BatchSize == 0),
+		"global_relay_customer_type":            *cfg.MessageExportSettings.GlobalRelaySettings.CustomerType,
+		"is_default_global_relay_smtp_username": isDefault(cfg.MessageExportSettings.GlobalRelaySettings.SmtpUsername, ""),
+	})
+}

tools/mattermost-govet/configtelemetry/type.go

@@ -0,0 +1,99 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package configtelemetry
+
+import (
+	"go/ast"
+	"go/token"
+	"strings"
+)
+
+var ignoreComments = []string{
+	"telemetry: none",
+	"Deprecated: do not use",
+}
+
+// typeFieldMap will generate map of its all possible selectors and adds them as a key. The value
+// is the position of the declaration in the type spec.
+func typeFieldMap(file *ast.File, typeName string) (map[string]token.Pos, error) {
+
+	var fieldsMap map[string]token.Pos
+
+	ast.Inspect(file, func(n ast.Node) bool {
+		decl, ok := n.(*ast.GenDecl)
+		if !ok || decl.Tok != token.TYPE || len(decl.Specs) < 1 {
+			return true
+		}
+
+		spec, ok := decl.Specs[0].(*ast.TypeSpec)
+		if !ok || spec.Name.Name != typeName {
+			return true
+		}
+
+		typ, ok := spec.Type.(*ast.StructType)
+		if !ok {
+			return true
+		}
+
+		fieldsMap = fields(typ)
+
+		return false
+	})
+
+	return fieldsMap, nil
+}
+
+func fields(str *ast.StructType) map[string]token.Pos {
+	structFields := make(map[string]token.Pos)
+
+	for _, field := range str.Fields.List {
+		if field.Comment != nil && ignored(field.Comment) {
+			continue
+		}
+
+		expr := field.Type
+		if ptr, ok := field.Type.(*ast.StarExpr); ok {
+			expr = ptr.X
+		}
+
+		if len(field.Names) != 1 {
+			panic("unhandled struct field definition")
+		}
+
+		key := field.Names[0].Name
+
+		v, ok := expr.(*ast.Ident)
+		if !ok || v.Obj == nil || v.Obj.Decl == nil {
+			structFields[key] = field.Pos()
+			continue
+		}
+
+		typeDecl, ok := v.Obj.Decl.(*ast.TypeSpec)
+		if !ok {
+			continue
+		}
+
+		typ, ok := typeDecl.Type.(*ast.StructType)
+		if !ok {
+			continue
+		}
+
+		for k, v := range fields(typ) {
+			structFields[key+"."+k] = v
+		}
+	}
+
+	return structFields
+}
+
+func ignored(comments *ast.CommentGroup) bool {
+	for _, comment := range comments.List {
+		for _, ignore := range ignoreComments {
+			if strings.Contains(comment.Text, ignore) {
+				return true
+			}
+		}
+	}
+	return false
+}