make update-workspace

apps/plugins/kinds/meta.cue

@@ -24,6 +24,7 @@ metaV0Alpha1: {
 			translations?: [string]: string
 			// +listType=atomic
 			children?: [...string]
+			aliasIds?: [...string]
 		}
 	}
 }

apps/plugins/pkg/apis/plugins/v0alpha1/meta_spec_gen.go

@@ -219,6 +219,7 @@ type MetaSpec struct {
 	Translations map[string]string          `json:"translations,omitempty"`
 	// +listType=atomic
 	Children []string `json:"children,omitempty"`
+	AliasIds []string `json:"aliasIds,omitempty"`
 }
 
 // NewMetaSpec creates a new MetaSpec object.

apps/plugins/pkg/app/meta/converter.go

@@ -573,6 +573,8 @@ func pluginStorePluginToMeta(plugin pluginstore.Plugin, loadingStrategy plugins.
 		metaSpec.Translations = plugin.Translations
 	}
 
+	metaSpec.AliasIds = plugin.AliasIDs
+
 	return metaSpec
 }
 
@@ -676,6 +678,8 @@ func pluginToMetaSpec(plugin *plugins.Plugin) pluginsv0alpha1.MetaSpec {
 		metaSpec.Translations = plugin.Translations
 	}
 
+	metaSpec.AliasIds = plugin.AliasIDs
+
 	return metaSpec
 }
 

conf/defaults.ini

@@ -336,7 +336,7 @@ rudderstack_data_plane_url =
 rudderstack_sdk_url =
 
 # Rudderstack v3 SDK, optional, defaults to false. If set, Rudderstack v3 SDK will be used instead of v1
-rudderstack_v3_sdk_url =
+rudderstack_v3_sdk_url = 
 
 # Rudderstack Config url, optional, used by Rudderstack SDK to fetch source config
 rudderstack_config_url =
@@ -2079,15 +2079,8 @@ enable =
 # To enable features by default, set `Expression:  "true"` in:
 # https://github.com/grafana/grafana/blob/main/pkg/services/featuremgmt/registry.go
 
-# The feature_toggles section now supports feature flags of different types,
-# including boolean, string, integer, float, and structured values, following the OpenFeature specification.
-# This feature is experimental and may change in future releases.
-#
 # feature1 = true
 # feature2 = false
-# feature3 = foobar
-# feature4 = 1.5
-# feature5 = { "foo": "bar" }
 
 [feature_toggles.openfeature]
 # This is EXPERIMENTAL. Please, do not use this section

pkg/services/featuremgmt/models.go

@@ -133,11 +133,7 @@ type FeatureFlag struct {
 	Stage       FeatureFlagStage `json:"stage,omitempty"`
 	Owner       codeowner        `json:"-"` // Owner person or team that owns this feature flag
 
-	// Expression defined by the feature_toggles configuration.
-	// Supports multiple types including boolean, string, integer, float,
-	// and structured values following the OpenFeature specification.
-	// Using the value "true" means the feature flag is enabled by default,
-	// Using the value "1.0" means the default value of the feature flag is 1.0
+	// CEL-GO expression.  Using the value "true" will mean this is on by default
 	Expression string `json:"expression,omitempty"`
 
 	// Special behavior properties

pkg/services/featuremgmt/openfeature.go

@@ -8,7 +8,6 @@ import (
 
 	clientauthmiddleware "github.com/grafana/grafana/pkg/clientauth/middleware"
 	"github.com/grafana/grafana/pkg/setting"
-	"github.com/open-feature/go-sdk/openfeature/memprovider"
 
 	sdkhttpclient "github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
 	"github.com/open-feature/go-sdk/openfeature"
@@ -27,7 +26,7 @@ type OpenFeatureConfig struct {
 	// HTTPClient is a pre-configured HTTP client (optional, used by features-service + OFREP providers)
 	HTTPClient *http.Client
 	// StaticFlags are the feature flags to use with static provider
-	StaticFlags map[string]memprovider.InMemoryFlag
+	StaticFlags map[string]bool
 	// TargetingKey is used for evaluation context
 	TargetingKey string
 	// ContextAttrs are additional attributes for evaluation context
@@ -101,7 +100,7 @@ func InitOpenFeatureWithCfg(cfg *setting.Cfg) error {
 func createProvider(
 	providerType string,
 	u *url.URL,
-	staticFlags map[string]memprovider.InMemoryFlag,
+	staticFlags map[string]bool,
 	httpClient *http.Client,
 ) (openfeature.FeatureProvider, error) {
 	if providerType == setting.FeaturesServiceProviderType || providerType == setting.OFREPProviderType {
@@ -118,7 +117,7 @@ func createProvider(
 		}
 	}
 
-	return newStaticProvider(staticFlags, standardFeatureFlags)
+	return newStaticProvider(staticFlags)
 }
 
 func createHTTPClient(m *clientauthmiddleware.TokenExchangeMiddleware) (*http.Client, error) {

pkg/services/featuremgmt/service.go

@@ -47,8 +47,7 @@ func ProvideManagerService(cfg *setting.Cfg) (*FeatureManager, error) {
 			}
 			mgmt.warnings[key] = "unknown flag in config"
 		}
-
-		mgmt.startup[key] = val.Variants[val.DefaultVariant] == true
+		mgmt.startup[key] = val
 	}
 
 	// update the values

pkg/services/featuremgmt/static_evaluator.go

@@ -29,7 +29,7 @@ func CreateStaticEvaluator(cfg *setting.Cfg) (StaticFlagEvaluator, error) {
 		return nil, fmt.Errorf("failed to read feature flags from config: %w", err)
 	}
 
-	staticProvider, err := newStaticProvider(staticFlags, standardFeatureFlags)
+	staticProvider, err := newStaticProvider(staticFlags)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create static provider: %w", err)
 	}

pkg/services/featuremgmt/static_provider.go

@@ -1,13 +1,8 @@
 package featuremgmt
 
 import (
-	"fmt"
-	"maps"
-
 	"github.com/open-feature/go-sdk/openfeature"
 	"github.com/open-feature/go-sdk/openfeature/memprovider"
-
-	"github.com/grafana/grafana/pkg/setting"
 )
 
 // inMemoryBulkProvider is a wrapper around memprovider.InMemoryProvider that
@@ -33,21 +28,37 @@ func (p *inMemoryBulkProvider) ListFlags() ([]string, error) {
 	return keys, nil
 }
 
-func newStaticProvider(confFlags map[string]memprovider.InMemoryFlag, standardFlags []FeatureFlag) (openfeature.FeatureProvider, error) {
-	flags := make(map[string]memprovider.InMemoryFlag, len(standardFlags))
-
-	// Parse and add standard flags
-	for _, flag := range standardFlags {
-		inMemFlag, err := setting.ParseFlag(flag.Name, flag.Expression)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse flag %s: %w", flag.Name, err)
-		}
-
-		flags[flag.Name] = inMemFlag
-	}
+func newStaticProvider(confFlags map[string]bool) (openfeature.FeatureProvider, error) {
+	flags := make(map[string]memprovider.InMemoryFlag, len(standardFeatureFlags))
 
 	// Add flags from config.ini file
-	maps.Copy(flags, confFlags)
+	for name, value := range confFlags {
+		flags[name] = createInMemoryFlag(name, value)
+	}
+
+	// Add standard flags
+	for _, flag := range standardFeatureFlags {
+		if _, exists := flags[flag.Name]; !exists {
+			enabled := flag.Expression == "true"
+			flags[flag.Name] = createInMemoryFlag(flag.Name, enabled)
+		}
+	}
 
 	return newInMemoryBulkProvider(flags), nil
 }
+
+func createInMemoryFlag(name string, enabled bool) memprovider.InMemoryFlag {
+	variant := "disabled"
+	if enabled {
+		variant = "enabled"
+	}
+
+	return memprovider.InMemoryFlag{
+		Key:            name,
+		DefaultVariant: variant,
+		Variants: map[string]interface{}{
+			"enabled":  true,
+			"disabled": false,
+		},
+	}
+}

pkg/services/featuremgmt/static_provider_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/grafana/grafana/pkg/setting"
-	"github.com/open-feature/go-sdk/openfeature/memprovider"
 
 	"github.com/open-feature/go-sdk/openfeature"
 	"github.com/stretchr/testify/assert"
@@ -94,144 +93,3 @@ ABCD = true
 	enabledFeatureManager := mgr.GetEnabled(ctx)
 	assert.Equal(t, openFeatureEnabledFlags, enabledFeatureManager)
 }
-
-func Test_StaticProvider_TypedFlags(t *testing.T) {
-	tests := []struct {
-		flags         FeatureFlag
-		defaultValue  any
-		expectedValue any
-	}{
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "true",
-			},
-			defaultValue:  false,
-			expectedValue: true,
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "1.0",
-			},
-			defaultValue:  0.0,
-			expectedValue: 1.0,
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "blue",
-			},
-			defaultValue:  "red",
-			expectedValue: "blue",
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: "1",
-			},
-			defaultValue:  int64(0),
-			expectedValue: int64(1),
-		},
-		{
-			flags: FeatureFlag{
-				Name:       "Flag",
-				Expression: `{ "foo": "bar" }`,
-			},
-			expectedValue: map[string]any{"foo": "bar"},
-		},
-	}
-
-	for _, tt := range tests {
-		provider, err := newStaticProvider(nil, []FeatureFlag{tt.flags})
-		assert.NoError(t, err)
-
-		var result any
-		switch tt.expectedValue.(type) {
-		case bool:
-			result = provider.BooleanEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(bool), openfeature.FlattenedContext{}).Value
-		case float64:
-			result = provider.FloatEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(float64), openfeature.FlattenedContext{}).Value
-		case string:
-			result = provider.StringEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(string), openfeature.FlattenedContext{}).Value
-		case int64:
-			result = provider.IntEvaluation(t.Context(), tt.flags.Name, tt.defaultValue.(int64), openfeature.FlattenedContext{}).Value
-		case map[string]any:
-			result = provider.ObjectEvaluation(t.Context(), tt.flags.Name, tt.defaultValue, openfeature.FlattenedContext{}).Value
-		}
-
-		assert.Equal(t, tt.expectedValue, result)
-	}
-}
-func Test_StaticProvider_ConfigOverride(t *testing.T) {
-	tests := []struct {
-		name          string
-		originalValue string
-		configValue   any
-	}{
-		{
-			name:          "bool",
-			originalValue: "false",
-			configValue:   true,
-		},
-		{
-			name:          "int",
-			originalValue: "0",
-			configValue:   int64(1),
-		},
-		{
-			name:          "float",
-			originalValue: "0.0",
-			configValue:   1.0,
-		},
-		{
-			name:          "string",
-			originalValue: "foo",
-			configValue:   "bar",
-		},
-		{
-			name:          "structure",
-			originalValue: "{}",
-			configValue:   make(map[string]any),
-		},
-	}
-
-	for _, tt := range tests {
-		configFlags, standardFlags := makeFlags(tt)
-		provider, err := newStaticProvider(configFlags, standardFlags)
-		assert.NoError(t, err)
-
-		var result any
-		switch tt.configValue.(type) {
-		case bool:
-			result = provider.BooleanEvaluation(t.Context(), tt.name, false, openfeature.FlattenedContext{}).Value
-		case float64:
-			result = provider.FloatEvaluation(t.Context(), tt.name, 0.0, openfeature.FlattenedContext{}).Value
-		case string:
-			result = provider.StringEvaluation(t.Context(), tt.name, "foo", openfeature.FlattenedContext{}).Value
-		case int64:
-			result = provider.IntEvaluation(t.Context(), tt.name, 1, openfeature.FlattenedContext{}).Value
-		case map[string]any:
-			result = provider.ObjectEvaluation(t.Context(), tt.name, make(map[string]any), openfeature.FlattenedContext{}).Value
-		}
-
-		assert.Equal(t, tt.configValue, result)
-	}
-}
-
-func makeFlags(tt struct {
-	name          string
-	originalValue string
-	configValue   any
-}) (map[string]memprovider.InMemoryFlag, []FeatureFlag) {
-	orig := FeatureFlag{
-		Name:       tt.name,
-		Expression: tt.originalValue,
-	}
-
-	config := map[string]memprovider.InMemoryFlag{
-		tt.name: setting.NewInMemoryFlag(tt.name, tt.configValue),
-	}
-
-	return config, []FeatureFlag{orig}
-}

pkg/services/updatemanager/plugins_test.go

@@ -10,7 +10,6 @@ import (
 	"testing"
 
 	"github.com/open-feature/go-sdk/openfeature"
-	"github.com/open-feature/go-sdk/openfeature/memprovider"
 	"github.com/stretchr/testify/require"
 
 	"github.com/grafana/grafana/pkg/infra/log"
@@ -379,10 +378,8 @@ func setupOpenFeatureProvider(t *testing.T, flagValue bool) {
 
 	err := featuremgmt.InitOpenFeature(featuremgmt.OpenFeatureConfig{
 		ProviderType: setting.StaticProviderType,
-		StaticFlags: map[string]memprovider.InMemoryFlag{
-			featuremgmt.FlagPluginsAutoUpdate: {
-				Key: featuremgmt.FlagPluginsAutoUpdate, Variants: map[string]any{"": flagValue},
-			},
+		StaticFlags: map[string]bool{
+			featuremgmt.FlagPluginsAutoUpdate: flagValue,
 		},
 	})
 	require.NoError(t, err)

pkg/setting/setting_feature_toggles.go

@@ -1,20 +1,13 @@
 package setting
 
 import (
-	"encoding/json"
-	"math"
 	"strconv"
 
 	"gopkg.in/ini.v1"
 
-	"github.com/open-feature/go-sdk/openfeature/memprovider"
-
 	"github.com/grafana/grafana/pkg/util"
 )
 
-// DefaultVariantName a placeholder name for config-based Feature Flags
-const DefaultVariantName = "default"
-
 // Deprecated: should use `featuremgmt.FeatureToggles`
 func (cfg *Cfg) readFeatureToggles(iniFile *ini.File) error {
 	section := iniFile.Section("feature_toggles")
@@ -22,27 +15,18 @@ func (cfg *Cfg) readFeatureToggles(iniFile *ini.File) error {
 	if err != nil {
 		return err
 	}
-	// TODO IsFeatureToggleEnabled has been deprecated for 2 years now, we should remove this function completely
 	// nolint:staticcheck
-	cfg.IsFeatureToggleEnabled = func(key string) bool {
-		toggle, ok := toggles[key]
-		if !ok {
-			return false
-		}
-
-		value, ok := toggle.Variants[toggle.DefaultVariant].(bool)
-		return value && ok
-	}
+	cfg.IsFeatureToggleEnabled = func(key string) bool { return toggles[key] }
 	return nil
 }
 
-func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[string]memprovider.InMemoryFlag, error) {
-	featureToggles := make(map[string]memprovider.InMemoryFlag, 10)
+func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[string]bool, error) {
+	featureToggles := make(map[string]bool, 10)
 
 	// parse the comma separated list in `enable`.
 	featuresTogglesStr := valueAsString(featureTogglesSection, "enable", "")
 	for _, feature := range util.SplitString(featuresTogglesStr) {
-		featureToggles[feature] = memprovider.InMemoryFlag{Key: feature, DefaultVariant: DefaultVariantName, Variants: map[string]any{DefaultVariantName: true}}
+		featureToggles[feature] = true
 	}
 
 	// read all other settings under [feature_toggles]. If a toggle is
@@ -52,7 +36,7 @@ func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[str
 			continue
 		}
 
-		b, err := ParseFlag(v.Name(), v.Value())
+		b, err := strconv.ParseBool(v.Value())
 		if err != nil {
 			return featureToggles, err
 		}
@@ -61,57 +45,3 @@ func ReadFeatureTogglesFromInitFile(featureTogglesSection *ini.Section) (map[str
 	}
 	return featureToggles, nil
 }
-
-func ParseFlag(name, value string) (memprovider.InMemoryFlag, error) {
-	var structure map[string]any
-
-	if integer, err := strconv.Atoi(value); err == nil {
-		return NewInMemoryFlag(name, integer), nil
-	}
-	if float, err := strconv.ParseFloat(value, 64); err == nil {
-		return NewInMemoryFlag(name, float), nil
-	}
-	if err := json.Unmarshal([]byte(value), &structure); err == nil {
-		return NewInMemoryFlag(name, structure), nil
-	}
-	if boolean, err := strconv.ParseBool(value); err == nil {
-		return NewInMemoryFlag(name, boolean), nil
-	}
-
-	return NewInMemoryFlag(name, value), nil
-}
-
-func NewInMemoryFlag(name string, value any) memprovider.InMemoryFlag {
-	return memprovider.InMemoryFlag{Key: name, DefaultVariant: DefaultVariantName, Variants: map[string]any{DefaultVariantName: value}}
-}
-
-func AsStringMap(m map[string]memprovider.InMemoryFlag) map[string]string {
-	var res = map[string]string{}
-	for k, v := range m {
-		res[k] = serializeFlagValue(v)
-	}
-	return res
-}
-
-func serializeFlagValue(flag memprovider.InMemoryFlag) string {
-	value := flag.Variants[flag.DefaultVariant]
-
-	switch castedValue := value.(type) {
-	case bool:
-		return strconv.FormatBool(castedValue)
-	case int64:
-		return strconv.FormatInt(castedValue, 10)
-	case float64:
-		// handle cases with a single or no zeros after the decimal point
-		if math.Trunc(castedValue) == castedValue {
-			return strconv.FormatFloat(castedValue, 'f', 1, 64)
-		}
-
-		return strconv.FormatFloat(castedValue, 'g', -1, 64)
-	case string:
-		return castedValue
-	default:
-		val, _ := json.Marshal(value)
-		return string(val)
-	}
-}

pkg/setting/setting_feature_toggles_test.go

@@ -1,11 +1,9 @@
 package setting
 
 import (
+	"strconv"
 	"testing"
 
-	"github.com/google/go-cmp/cmp"
-	"github.com/open-feature/go-sdk/openfeature/memprovider"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gopkg.in/ini.v1"
 )
@@ -14,16 +12,17 @@ func TestFeatureToggles(t *testing.T) {
 	testCases := []struct {
 		name            string
 		conf            map[string]string
-		expectedToggles map[string]memprovider.InMemoryFlag
+		err             error
+		expectedToggles map[string]bool
 	}{
 		{
 			name: "can parse feature toggles passed in the `enable` array",
 			conf: map[string]string{
 				"enable": "feature1,feature2",
 			},
-			expectedToggles: map[string]memprovider.InMemoryFlag{
-				"feature1": NewInMemoryFlag("feature1", true),
-				"feature2": NewInMemoryFlag("feature2", true),
+			expectedToggles: map[string]bool{
+				"feature1": true,
+				"feature2": true,
 			},
 		},
 		{
@@ -32,10 +31,10 @@ func TestFeatureToggles(t *testing.T) {
 				"enable":   "feature1,feature2",
 				"feature3": "true",
 			},
-			expectedToggles: map[string]memprovider.InMemoryFlag{
-				"feature1": NewInMemoryFlag("feature1", true),
-				"feature2": NewInMemoryFlag("feature2", true),
-				"feature3": NewInMemoryFlag("feature3", true),
+			expectedToggles: map[string]bool{
+				"feature1": true,
+				"feature2": true,
+				"feature3": true,
 			},
 		},
 		{
@@ -44,26 +43,19 @@ func TestFeatureToggles(t *testing.T) {
 				"enable":   "feature1,feature2",
 				"feature2": "false",
 			},
-			expectedToggles: map[string]memprovider.InMemoryFlag{
-				"feature1": NewInMemoryFlag("feature1", true),
-				"feature2": NewInMemoryFlag("feature2", false),
+			expectedToggles: map[string]bool{
+				"feature1": true,
+				"feature2": false,
 			},
 		},
 		{
-			name: "feature flags of different types are handled correctly",
+			name: "invalid boolean value should return syntax error",
 			conf: map[string]string{
-				"feature1": "1", "feature2": "1.0",
-				"feature3": `{"foo":"bar"}`, "feature4": "bar",
-				"feature5": "t", "feature6": "T",
-			},
-			expectedToggles: map[string]memprovider.InMemoryFlag{
-				"feature1": NewInMemoryFlag("feature1", 1),
-				"feature2": NewInMemoryFlag("feature2", 1.0),
-				"feature3": NewInMemoryFlag("feature3", map[string]any{"foo": "bar"}),
-				"feature4": NewInMemoryFlag("feature4", "bar"),
-				"feature5": NewInMemoryFlag("feature5", true),
-				"feature6": NewInMemoryFlag("feature6", true),
+				"enable":   "feature1,feature2",
+				"feature2": "invalid",
 			},
+			expectedToggles: map[string]bool{},
+			err:             strconv.ErrSyntax,
 		},
 	}
 
@@ -77,35 +69,12 @@ func TestFeatureToggles(t *testing.T) {
 		}
 
 		featureToggles, err := ReadFeatureTogglesFromInitFile(toggles)
-		require.NoError(t, err)
+		require.ErrorIs(t, err, tc.err)
 
-		for k, v := range featureToggles {
-			toggle := tc.expectedToggles[k]
-			require.Equal(t, toggle, v, tc.name)
-		}
-	}
-}
-
-func TestFlagValueSerialization(t *testing.T) {
-	testCases := []memprovider.InMemoryFlag{
-		NewInMemoryFlag("int", 1),
-		NewInMemoryFlag("1.0f", 1.0),
-		NewInMemoryFlag("1.01f", 1.01),
-		NewInMemoryFlag("1.10f", 1.10),
-		NewInMemoryFlag("struct", map[string]any{"foo": "bar"}),
-		NewInMemoryFlag("string", "bar"),
-		NewInMemoryFlag("true", true),
-		NewInMemoryFlag("false", false),
-	}
-
-	for _, tt := range testCases {
-		asStringMap := AsStringMap(map[string]memprovider.InMemoryFlag{tt.Key: tt})
-
-		deserialized, err := ParseFlag(tt.Key, asStringMap[tt.Key])
-		assert.NoError(t, err)
-
-		if diff := cmp.Diff(tt, deserialized); diff != "" {
-			t.Errorf("(-want, +got) = %v", diff)
+		if err == nil {
+			for k, v := range featureToggles {
+				require.Equal(t, tc.expectedToggles[k], v, tc.name)
+			}
 		}
 	}
 }

pkg/tests/apis/features/features_test.go

@@ -44,6 +44,6 @@ func TestIntegrationFeatures(t *testing.T) {
 			"value": true,
 			"key":"`+flag+`",
 			"reason":"static provider evaluation result",
-			"variant":"default"}`, string(rsp.Body))
+			"variant":"enabled"}`, string(rsp.Body))
 	})
 }

pkg/util/testutil/context_test.go

@@ -15,10 +15,7 @@ import (
 func TestMain(m *testing.M) {
 	// make sure we don't leak goroutines after tests in this package have
 	// finished, which means we haven't leaked contexts either
-	// (Except for goroutines running specific functions. If possible we should fix this.)
-	goleak.VerifyTestMain(m,
-		goleak.IgnoreTopFunction("github.com/open-feature/go-sdk/openfeature.(*eventExecutor).startEventListener.func1.1"),
-	)
+	goleak.VerifyTestMain(m)
 }
 
 func TestTestContextFunc(t *testing.T) {