[MM-32390] Config logic refactor (#17578)

* Replace config generator

* Cleanup

* Some renaming and docs additions to add clarity

* Cleanup logging related methods

* Cleanup emitter

* Fix TestDefaultsGenerator

* Move feature flags synchronization logic out of config package

* Remove unnecessary util functions

* Simplify load/set logic

* Refine semantics and add some test to cover them

* Remove unnecessary deep copies

* Improve logic further

* Fix license header

* Review file store tests

* Fix test

* Fix test

* Avoid additional write during initialization

* More consistent naming

* Update app/feature_flags.go

Co-authored-by: Christopher Speller <crspeller@gmail.com>

* Update config/store.go

Co-authored-by: Christopher Speller <crspeller@gmail.com>

* Update config/store.go

Co-authored-by: Christopher Speller <crspeller@gmail.com>

* Update config/store.go

Co-authored-by: Ibrahim Serdar Acikgoz <serdaracikgoz86@gmail.com>

* Move FF synchronizer to its own package

* Remove unidiomatic use of sync.Once

* Add some comments

* Rename function

* More comment

Co-authored-by: Christopher Speller <crspeller@gmail.com>
Co-authored-by: Ibrahim Serdar Acikgoz <serdaracikgoz86@gmail.com>

app/audit.go

@@ -143,15 +143,12 @@ func (s *Server) configureAudit(adt *audit.Audit, bAllowAdvancedLogging bool) er
 	if !bAllowAdvancedLogging || dsn == "" {
 		return errs
 	}
-	isJson := config.IsJsonMap(dsn)
-	cfg, err := config.NewLogConfigSrc(dsn, isJson, s.configStore)
+	cfg, err := config.NewLogConfigSrc(dsn, s.configStore)
 	if err != nil {
 		errs = multierror.Append(fmt.Errorf("invalid config for audit, %w", err))
 		return errs
 	}
-	if !isJson {
-		mlog.Debug("Loaded audit configuration", mlog.String("filename", dsn))
-	}
+	mlog.Debug("Loaded audit configuration", mlog.String("source", dsn))
 
 	for name, t := range cfg.Get() {
 		if len(t.Levels) == 0 {

app/feature_flags.go

@@ -8,7 +8,7 @@ import (
 	"os"
 	"time"
 
-	"github.com/mattermost/mattermost-server/v5/config"
+	"github.com/mattermost/mattermost-server/v5/app/featureflag"
 	"github.com/mattermost/mattermost-server/v5/shared/mlog"
 )
 
@@ -21,7 +21,7 @@ func (s *Server) setupFeatureFlags() {
 	splitConfigured := splitKey != ""
 	syncFeatureFlags := splitConfigured && s.IsLeader()
 
-	s.configStore.PersistFeatures(splitConfigured)
+	s.configStore.SetReadOnlyFF(!splitConfigured)
 
 	if syncFeatureFlags {
 		if err := s.startFeatureFlagUpdateJob(); err != nil {
@@ -71,7 +71,7 @@ func (s *Server) startFeatureFlagUpdateJob() error {
 		attributes["group_id"] = groupId
 	}
 
-	synchronizer, err := config.NewFeatureFlagSynchronizer(config.FeatureFlagSyncParams{
+	synchronizer, err := featureflag.NewSynchronizer(featureflag.SyncParams{
 		ServerID:   s.TelemetryId(),
 		SplitKey:   *s.Config().ServiceSettings.SplitKey,
 		Log:        log,

app/featureflag/feature_flags_sync.go

@@ -0,0 +1,111 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package featureflag
+
+import (
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/splitio/go-client/v6/splitio/client"
+	"github.com/splitio/go-client/v6/splitio/conf"
+
+	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/shared/mlog"
+)
+
+type SyncParams struct {
+	ServerID            string
+	SplitKey            string
+	SyncIntervalSeconds int
+	Log                 *mlog.Logger
+	Attributes          map[string]interface{}
+}
+
+type Synchronizer struct {
+	SyncParams
+
+	client  *client.SplitClient
+	stop    chan struct{}
+	stopped chan struct{}
+}
+
+var featureNames = getStructFields(model.FeatureFlags{})
+
+func NewSynchronizer(params SyncParams) (*Synchronizer, error) {
+	cfg := conf.Default()
+	if params.Log != nil {
+		cfg.Logger = &splitLogger{wrappedLog: params.Log.With(mlog.String("service", "split"))}
+	} else {
+		cfg.LoggerConfig.LogLevel = math.MinInt32
+	}
+	factory, err := client.NewSplitFactory(params.SplitKey, cfg)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create split factory")
+	}
+
+	return &Synchronizer{
+		SyncParams: params,
+		client:     factory.Client(),
+		stop:       make(chan struct{}),
+		stopped:    make(chan struct{}),
+	}, nil
+}
+
+// EnsureReady blocks until the syncronizer is ready to update feature flag values
+func (f *Synchronizer) EnsureReady() error {
+	if err := f.client.BlockUntilReady(10); err != nil {
+		return errors.Wrap(err, "split.io client could not initialize")
+	}
+
+	return nil
+}
+
+func (f *Synchronizer) UpdateFeatureFlagValues(base model.FeatureFlags) model.FeatureFlags {
+	featuresMap := f.client.Treatments(f.ServerID, featureNames, f.Attributes)
+	ffm := featureFlagsFromMap(featuresMap, base)
+	return ffm
+}
+
+func (f *Synchronizer) Close() {
+	f.client.Destroy()
+}
+
+// featureFlagsFromMap sets the feature flags from a map[string]string.
+// It starts with baseFeatureFlags and only sets values that are
+// given by the upstream management system.
+// Makes the assumption that all feature flags are strings or booleans.
+// Strings are converted to booleans by considering case insensitive "on" or any value considered by strconv.ParseBool as true and any other value as false.
+func featureFlagsFromMap(featuresMap map[string]string, baseFeatureFlags model.FeatureFlags) model.FeatureFlags {
+	refStruct := reflect.ValueOf(&baseFeatureFlags).Elem()
+	for fieldName, fieldValue := range featuresMap {
+		refField := refStruct.FieldByName(fieldName)
+		// "control" is returned by split.io if the treatment is not found, in this case we should use the default value.
+		if !refField.IsValid() || !refField.CanSet() || fieldValue == "control" {
+			continue
+		}
+
+		switch refField.Type().Kind() {
+		case reflect.Bool:
+			parsedBoolValue, _ := strconv.ParseBool(fieldValue)
+			refField.Set(reflect.ValueOf(strings.ToLower(fieldValue) == "on" || parsedBoolValue))
+		default:
+			refField.Set(reflect.ValueOf(fieldValue))
+		}
+
+	}
+	return baseFeatureFlags
+}
+
+func getStructFields(s interface{}) []string {
+	structType := reflect.TypeOf(s)
+	fieldNames := make([]string, 0, structType.NumField())
+	for i := 0; i < structType.NumField(); i++ {
+		fieldNames = append(fieldNames, structType.Field(i).Name)
+	}
+
+	return fieldNames
+}

app/featureflag/feature_flags_sync_test.go

@@ -0,0 +1,111 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package featureflag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v5/model"
+)
+
+func TestGetStructFields(t *testing.T) {
+	type testStruct struct {
+		FieldOne       string
+		SecondField    bool
+		SomeOtherField int
+	}
+
+	fields := getStructFields(testStruct{})
+	require.Equal(t,
+		[]string{
+			"FieldOne",
+			"SecondField",
+			"SomeOtherField",
+		},
+		fields,
+	)
+
+	featureFlagsFields := getStructFields(model.FeatureFlags{})
+	require.Contains(t, featureFlagsFields, "TestFeature")
+}
+
+func TestFeatureFlagsFromMap(t *testing.T) {
+	for name, tc := range map[string]struct {
+		FeatureMap        map[string]string
+		Base              model.FeatureFlags
+		ExpectedTestValue string
+	}{
+		"empty": {
+			FeatureMap:        map[string]string{},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"no base value": {
+			FeatureMap:        map[string]string{"TestFeature": "expectedvalue"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "expectedvalue",
+		},
+		"only base value": {
+			FeatureMap:        map[string]string{},
+			Base:              model.FeatureFlags{TestFeature: "somebasevalue"},
+			ExpectedTestValue: "somebasevalue",
+		},
+		"override base value": {
+			FeatureMap:        map[string]string{"TestFeature": "overridevalue"},
+			Base:              model.FeatureFlags{TestFeature: "somebasevalue"},
+			ExpectedTestValue: "overridevalue",
+		},
+		"override base value with extras": {
+			FeatureMap:        map[string]string{"TestFeature": "overridevalue", "SomeOldFlag": "oldvalue"},
+			Base:              model.FeatureFlags{TestFeature: "somebasevalue"},
+			ExpectedTestValue: "overridevalue",
+		},
+		"all values do not exist": {
+			FeatureMap:        map[string]string{"SomeOldFlag": "oldvalue"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"bool on": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "on"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool true": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "true"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool True": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "True"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool 1": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "1"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool off": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "off"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"bool false": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "false"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"bool other value": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "someotherbadvalue"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			require.Equal(t, tc.ExpectedTestValue, featureFlagsFromMap(tc.FeatureMap, tc.Base).TestFeature)
+		})
+	}
+}

app/featureflag/split_logger.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package featureflag
+
+import (
+	"fmt"
+
+	"github.com/mattermost/mattermost-server/v5/shared/mlog"
+)
+
+type splitLogger struct {
+	wrappedLog *mlog.Logger
+}
+
+func (s *splitLogger) Error(msg ...interface{}) {
+	s.wrappedLog.Error(fmt.Sprint(msg...))
+}
+
+func (s *splitLogger) Warning(msg ...interface{}) {
+	s.wrappedLog.Warn(fmt.Sprint(msg...))
+}
+
+// Ignoring more verbose messages from split
+func (s *splitLogger) Info(msg ...interface{}) {
+	//s.wrappedLog.Info(fmt.Sprint(msg...))
+}
+
+func (s *splitLogger) Debug(msg ...interface{}) {
+	//s.wrappedLog.Debug(fmt.Sprint(msg...))
+}
+
+func (s *splitLogger) Verbose(msg ...interface{}) {
+	//s.wrappedLog.Info(fmt.Sprint(msg...))
+}

app/options.go

@@ -45,7 +45,7 @@ func StoreOverride(override interface{}) Option {
 // config loaded from the dsn on top of the normal defaults
 func Config(dsn string, watch, readOnly bool, configDefaults *model.Config) Option {
 	return func(s *Server) error {
-		configStore, err := config.NewStore(dsn, watch, readOnly, configDefaults)
+		configStore, err := config.NewStoreFromDSN(dsn, watch, readOnly, configDefaults)
 		if err != nil {
 			return errors.Wrap(err, "failed to apply Config option")
 		}

app/server.go

@@ -19,7 +19,6 @@ import (
 	"os"
 	"os/exec"
 	"path"
-	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
@@ -38,6 +37,7 @@ import (
 	"github.com/rs/cors"
 	"golang.org/x/crypto/acme/autocert"
 
+	"github.com/mattermost/mattermost-server/v5/app/featureflag"
 	"github.com/mattermost/mattermost-server/v5/app/request"
 	"github.com/mattermost/mattermost-server/v5/audit"
 	"github.com/mattermost/mattermost-server/v5/config"
@@ -200,7 +200,7 @@ type Server struct {
 	uploadLockMapMut sync.Mutex
 	uploadLockMap    map[string]bool
 
-	featureFlagSynchronizer      *config.FeatureFlagSynchronizer
+	featureFlagSynchronizer      *featureflag.Synchronizer
 	featureFlagStop              chan struct{}
 	featureFlagStopped           chan struct{}
 	featureFlagSynchronizerMutex sync.Mutex
@@ -805,15 +805,8 @@ func (s *Server) initLogging() error {
 	// shutdown once license is loaded/checked.
 	if *s.Config().LogSettings.AdvancedLoggingConfig != "" {
 		dsn := *s.Config().LogSettings.AdvancedLoggingConfig
-		isJson := config.IsJsonMap(dsn)
 
-		// If this is a file based config we need the full path so it can be watched.
-		if !isJson && strings.HasPrefix(s.configStore.String(), "file://") && !filepath.IsAbs(dsn) {
-			configPath := strings.TrimPrefix(s.configStore.String(), "file://")
-			dsn = filepath.Join(filepath.Dir(configPath), dsn)
-		}
-
-		cfg, err := config.NewLogConfigSrc(dsn, isJson, s.configStore)
+		cfg, err := config.NewLogConfigSrc(dsn, s.configStore)
 		if err != nil {
 			return fmt.Errorf("invalid advanced logging config, %w", err)
 		}
@@ -822,9 +815,7 @@ func (s *Server) initLogging() error {
 			return fmt.Errorf("error configuring advanced logging, %w", err)
 		}
 
-		if !isJson {
-			mlog.Info("Loaded advanced logging config", mlog.String("source", dsn))
-		}
+		mlog.Info("Loaded advanced logging config", mlog.String("source", dsn))
 
 		listenerId := cfg.AddListener(func(_, newCfg mlog.LogTargetCfg) {
 			if err := s.Log.ConfigAdvancedLogging(newCfg); err != nil {