filter gcir option (#260)

add option to filter to specific entity types for gcir

Author: kat-statsig

client.go

@@ -338,6 +338,7 @@ func (c *Client) GetClientInitializeResponseImpl(user User, options *GCIROptions
 		TargetAppID:           options.TargetAppID,
 		Hash:                  options.HashAlgorithm,
 		IncludeConfigType:     options.IncludeConfigType,
+		ConfigTypesToInclude:  options.ConfigTypesToInclude,
 	})
 }
 

client_initialize_response.go

@@ -23,19 +23,6 @@ type SDKInfo struct {
 	SDKVersion string `json:"sdkVersion"`
 }
 
-type ConfigType = string
-
-const (
-	FeatureGateType   ConfigType = "feature_gate"
-	HoldoutType       ConfigType = "holdout"
-	SegmentType       ConfigType = "segment"
-	DynamicConfigType ConfigType = "dynamic_config"
-	ExperimentType    ConfigType = "experiment"
-	AutotuneType      ConfigType = "autotune"
-	LayerType         ConfigType = "layer"
-	UnknownType       ConfigType = "unknown"
-)
-
 type baseSpecInitializeResponse struct {
 	Name               string              `json:"name"`
 	RuleID             string              `json:"rule_id"`
@@ -254,13 +241,34 @@ func getClientInitializeResponse(
 		}
 	}
 
+	configTypesMap := make(map[ConfigType]struct{})
+	if context.ConfigTypesToInclude != nil {
+		for _, configType := range context.ConfigTypesToInclude {
+			configTypesMap[configType] = struct{}{}
+		}
+	}
+
+	shouldFilterConfigType := func(specType ConfigType) bool {
+		if context.ConfigTypesToInclude == nil {
+			return false
+		}
+		if _, exists := configTypesMap[specType]; exists {
+			return false
+		}
+		return true
+
+	}
+
 	featureGates := make(map[string]GateInitializeResponse)
 	dynamicConfigs := make(map[string]ConfigInitializeResponse)
 	layerConfigs := make(map[string]LayerInitializeResponse)
 	for name, spec := range e.store.featureGates {
 		if !spec.hasTargetAppID(appId) {
 			continue
 		}
+		if shouldFilterConfigType(getConfigType(spec)) {
+			continue
+		}
 		if filterByEntities {
 			if _, ok := gatesLookup[name]; !ok {
 				continue
@@ -275,6 +283,9 @@ func getClientInitializeResponse(
 		if !spec.hasTargetAppID(appId) {
 			continue
 		}
+		if shouldFilterConfigType(getConfigType(spec)) {
+			continue
+		}
 		if filterByEntities {
 			if _, ok := configsLookup[name]; !ok {
 				continue
@@ -287,6 +298,9 @@ func getClientInitializeResponse(
 		if !spec.hasTargetAppID(appId) {
 			continue
 		}
+		if shouldFilterConfigType(getConfigType(spec)) {
+			continue
+		}
 		hashedName, res := layerToResponse(name, spec)
 		layerConfigs[hashedName] = res
 	}

client_initialize_response_test.go

@@ -148,6 +148,116 @@ func TestClientInitializeResponseOptions(t *testing.T) {
 	}
 }
 
+func TestClientInitializeResponseFilterOptions(t *testing.T) {
+	user := User{
+		UserID:    "123",
+		Email:     "[email protected]",
+		Country:   "US",
+		Custom:    map[string]interface{}{"test": "123"},
+		CustomIDs: map[string]string{"stableID": "12345"},
+	}
+
+	InitializeWithOptions(secret, &Options{
+		OutputLoggerOptions:  getOutputLoggerOptionsForTest(t),
+		StatsigLoggerOptions: getStatsigLoggerOptionsForTest(t),
+	})
+	defer ShutdownAndDangerouslyClearInstance()
+
+	tests := []struct {
+		name        string
+		filter      *GCIROptions
+		expectGate  bool
+		expectDC    bool
+		expectExp   bool
+		expectAT    bool
+		expectLayer bool
+	}{
+		{
+			name:       "Include all entities",
+			filter:     &GCIROptions{HashAlgorithm: "none"},
+			expectGate: true, expectDC: true, expectExp: true, expectAT: true, expectLayer: true,
+		},
+		{
+			name:       "Only feature gates",
+			filter:     &GCIROptions{HashAlgorithm: "none", ConfigTypesToInclude: []ConfigType{FeatureGateType}},
+			expectGate: true, expectDC: false, expectExp: false, expectAT: false, expectLayer: false,
+		},
+		{
+			name:       "Only dynamic configs",
+			filter:     &GCIROptions{HashAlgorithm: "none", ConfigTypesToInclude: []ConfigType{DynamicConfigType}},
+			expectGate: false, expectDC: true, expectExp: false, expectAT: false, expectLayer: false,
+		},
+		{
+			name:       "Only experiments",
+			filter:     &GCIROptions{HashAlgorithm: "none", ConfigTypesToInclude: []ConfigType{ExperimentType}},
+			expectGate: false, expectDC: false, expectExp: true, expectAT: false, expectLayer: false,
+		},
+		{
+			name:       "Only autotune configs",
+			filter:     &GCIROptions{HashAlgorithm: "none", ConfigTypesToInclude: []ConfigType{AutotuneType}},
+			expectGate: false, expectDC: false, expectExp: false, expectAT: true, expectLayer: false,
+		},
+		{
+			name:       "Only layers",
+			filter:     &GCIROptions{HashAlgorithm: "none", ConfigTypesToInclude: []ConfigType{LayerType}},
+			expectGate: false, expectDC: false, expectExp: false, expectAT: false, expectLayer: true,
+		},
+		{
+			name:       "Include multiple entities (feature gates and experiments)",
+			filter:     &GCIROptions{HashAlgorithm: "none", ConfigTypesToInclude: []ConfigType{FeatureGateType, ExperimentType}},
+			expectGate: true, expectDC: false, expectExp: true, expectAT: false, expectLayer: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			response := GetClientInitializeResponseWithOptions(user, tt.filter)
+
+			var featureGate GateInitializeResponse
+			var dynamicConfig ConfigInitializeResponse
+			var experiment ConfigInitializeResponse
+			var autotune ConfigInitializeResponse
+			var layer LayerInitializeResponse
+
+			for _, g := range response.FeatureGates {
+				if g.Name == "test_public" {
+					featureGate = g
+				}
+			}
+			for _, c := range response.DynamicConfigs {
+				if c.Name == "test_custom_config" {
+					dynamicConfig = c
+				} else if c.Name == "test_experiment_with_targeting" {
+					experiment = c
+				} else if c.Name == "test_autotune" {
+					autotune = c
+				}
+			}
+			for _, l := range response.LayerConfigs {
+				if l.Name == "Basic_test_layer" {
+					layer = l
+				}
+			}
+
+			if (featureGate.Name != "") != tt.expectGate {
+				t.Errorf("Feature gate presence mismatch: got %v, want %v", featureGate.Name != "", tt.expectGate)
+			}
+			if (dynamicConfig.Name != "") != tt.expectDC {
+				t.Errorf("Dynamic config presence mismatch: got %v, want %v", dynamicConfig.Name != "", tt.expectDC)
+			}
+			if (experiment.Name != "") != tt.expectExp {
+				t.Errorf("Experiment presence mismatch: got %v, want %v", experiment.Name != "", tt.expectExp)
+			}
+			if (autotune.Name != "") != tt.expectAT {
+				t.Errorf("Autotune config presence mismatch: got %v, want %v", autotune.Name != "", tt.expectAT)
+			}
+			if (layer.Name != "") != tt.expectLayer {
+				t.Errorf("Layer presence mismatch: got %v, want %v", layer.Name != "", tt.expectLayer)
+			}
+		})
+	}
+}
+
 func filterHttpResponseAndReadBody(httpResponse *http.Response) ([]byte, error) {
 	var interfaceBody ClientInitializeResponse
 	// Initialize nullable fields so that JSON Unmarshal doesn't convert to null

statsig_context.go

@@ -25,6 +25,7 @@ type evalContext struct {
 	DisableLogExposures   bool
 	PersistedValues       UserPersistedValues
 	IncludeConfigType     bool
+	ConfigTypesToInclude  []ConfigType
 }
 
 type initContext struct {

statsig_options.go

@@ -91,4 +91,18 @@ type GCIROptions struct {
 	TargetAppID           string
 	HashAlgorithm         string
 	IncludeConfigType     bool
+	ConfigTypesToInclude  []ConfigType
 }
+
+type ConfigType = string
+
+const (
+	FeatureGateType   ConfigType = "feature_gate"
+	HoldoutType       ConfigType = "holdout"
+	SegmentType       ConfigType = "segment"
+	DynamicConfigType ConfigType = "dynamic_config"
+	ExperimentType    ConfigType = "experiment"
+	AutotuneType      ConfigType = "autotune"
+	LayerType         ConfigType = "layer"
+	UnknownType       ConfigType = "unknown"
+)