thomaspoignant
diff --git a/‎cmd/relayproxy/config/config.go
+51-19 b/‎cmd/relayproxy/config/config.go
+51-19
diff --git a/‎cmd/relayproxy/config/config_test.go
+78 b/‎cmd/relayproxy/config/config_test.go
+78
diff --git a/‎cmd/relayproxy/service/gofeatureflag.go
+53-27 b/‎cmd/relayproxy/service/gofeatureflag.go
+53-27
@@ -101,7 +101,8 @@ func New(flagSet *pflag.FlagSet, log *zap.Logger, version string) (*Config, erro
 	// Map environment variables
 	_ = k.Load(env.ProviderWithValue("", ".", func(s string, v string) (string, interface{}) {
 		if strings.HasPrefix(s, "RETRIEVERS") ||
-			strings.HasPrefix(s, "NOTIFIERS") {
+			strings.HasPrefix(s, "NOTIFIERS") ||
+			strings.HasPrefix(s, "EXPORTERS") {
 			configMap := k.Raw()
 			err := loadArrayEnv(s, v, configMap)
 			if err != nil {
@@ -256,6 +257,14 @@ type Config struct {
 	// Exporter is the configuration on how to export data
 	Exporter *ExporterConf `mapstructure:"exporter" koanf:"exporter"`
 
+	// Exporters is the exact same things than Exporter but allows to give more than 1 exporter at the time.
+	Exporters *[]ExporterConf `mapstructure:"exporters" koanf:"exporters"`
+
+	// ExporterCleanQueueInterval (optional) is the duration between each cleaning of the queue by the thread in charge
+	// of removing the old events.
+	// Default: 1 minute
+	ExporterCleanQueueInterval time.Duration `mapstructure:"exporterCleanQueueInterval" koanf:"exportercleanqueueinterval"`
+
 	// Notifiers is the configuration on where to notify a flag change
 	Notifiers []NotifierConf `mapstructure:"notifier" koanf:"notifier"`
 
@@ -413,15 +422,41 @@ func (c *Config) IsValid() error {
 	if c == nil {
 		return fmt.Errorf("empty config")
 	}
-
 	if c.ListenPort == 0 {
 		return fmt.Errorf("invalid port %d", c.ListenPort)
 	}
+	if c.LogLevel != "" {
+		if _, err := zapcore.ParseLevel(c.LogLevel); err != nil {
+			return err
+		}
+	}
+	if err := c.validateRetrievers(); err != nil {
+		return err
+	}
+
+	if err := c.validateExporters(); err != nil {
+		return err
+	}
+
+	if err := c.validateNotifiers(); err != nil {
+		return err
+	}
+
+	// log format validation
+	switch strings.ToLower(c.LogFormat) {
+	case "json", "logfmt", "":
+		break
+	default:
+		return fmt.Errorf("invalid log format %s", c.LogFormat)
+	}
+
+	return nil
+}
 
+func (c *Config) validateRetrievers() error {
 	if c.Retriever == nil && c.Retrievers == nil {
 		return fmt.Errorf("no retriever available in the configuration")
 	}
-
 	if c.Retriever != nil {
 		if err := c.Retriever.IsValid(); err != nil {
 			return err
@@ -435,35 +470,32 @@ func (c *Config) IsValid() error {
 			}
 		}
 	}
+	return nil
+}
 
-	// Exporter is optional
+func (c *Config) validateExporters() error {
 	if c.Exporter != nil {
 		if err := c.Exporter.IsValid(); err != nil {
 			return err
 		}
 	}
-
+	if c.Exporters != nil {
+		for _, exporter := range *c.Exporters {
+			if err := exporter.IsValid(); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+func (c *Config) validateNotifiers() error {
 	if c.Notifiers != nil {
 		for _, notif := range c.Notifiers {
 			if err := notif.IsValid(); err != nil {
 				return err
 			}
 		}
 	}
-	if c.LogLevel != "" {
-		if _, err := zapcore.ParseLevel(c.LogLevel); err != nil {
-			return err
-		}
-	}
-
-	// log format validation
-	switch strings.ToLower(c.LogFormat) {
-	case "json", "logfmt", "":
-		break
-	default:
-		return fmt.Errorf("invalid log format %s", c.LogFormat)
-	}
-
 	return nil
 }
 
 
@@ -87,6 +87,84 @@ func TestParseConfig_fileFromPflag(t *testing.T) {
 			},
 			wantErr: assert.NoError,
 		},
+		{
+			name:         "Valid yaml file with multiple exporters",
+			fileLocation: "../testdata/config/valid-yaml-multiple-exporters.yaml",
+			want: &config.Config{
+				ListenPort:      1031,
+				PollingInterval: 1000,
+				FileFormat:      "yaml",
+				Host:            "localhost",
+				Retriever: &config.RetrieverConf{
+					Kind: "http",
+					URL:  "https://raw.githubusercontent.com/thomaspoignant/go-feature-flag/main/examples/retriever_file/flags.goff.yaml",
+				},
+				Exporters: &[]config.ExporterConf{
+					{
+						Kind: "log",
+					},
+					{
+						Kind:      "file",
+						OutputDir: "./",
+					},
+				},
+				StartWithRetrieverError: false,
+				Version:                 "1.X.X",
+				EnableSwagger:           true,
+				AuthorizedKeys: config.APIKeys{
+					Admin: []string{
+						"apikey3",
+					},
+					Evaluation: []string{
+						"apikey1",
+						"apikey2",
+					},
+				},
+				LogLevel: "info",
+			},
+			wantErr: assert.NoError,
+		},
+		{
+			name:         "Valid yaml file with both exporter and exporters",
+			fileLocation: "../testdata/config/valid-yaml-exporter-and-exporters.yaml",
+			want: &config.Config{
+				ListenPort:      1031,
+				PollingInterval: 1000,
+				FileFormat:      "yaml",
+				Host:            "localhost",
+				Retriever: &config.RetrieverConf{
+					Kind: "http",
+					URL:  "https://raw.githubusercontent.com/thomaspoignant/go-feature-flag/main/examples/retriever_file/flags.goff.yaml",
+				},
+				Exporter: &config.ExporterConf{
+					Kind: "log",
+				},
+				Exporters: &[]config.ExporterConf{
+					{
+						Kind:        "webhook",
+						EndpointURL: "https://example.com/webhook",
+					},
+					{
+						Kind:      "file",
+						OutputDir: "./",
+					},
+				},
+				StartWithRetrieverError: false,
+				Version:                 "1.X.X",
+				EnableSwagger:           true,
+				AuthorizedKeys: config.APIKeys{
+					Admin: []string{
+						"apikey3",
+					},
+					Evaluation: []string{
+						"apikey1",
+						"apikey2",
+					},
+				},
+				LogLevel: "info",
+			},
+			wantErr: assert.NoError,
+		},
 		{
 			name:         "Valid json file",
 			fileLocation: "../testdata/config/valid-file.json",
 
@@ -47,38 +47,19 @@ func NewGoFeatureFlagClient(
 	logger *zap.Logger,
 	notifiers []notifier.Notifier,
 ) (*ffclient.GoFeatureFlag, error) {
-	var mainRetriever retriever.Retriever
 	var err error
-
 	if proxyConf == nil {
 		return nil, fmt.Errorf("proxy config is empty")
 	}
 
-	if proxyConf.Retriever != nil {
-		mainRetriever, err = initRetriever(proxyConf.Retriever)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// Manage if we have more than 1 retriever
-	retrievers := make([]retriever.Retriever, 0)
-	if proxyConf.Retrievers != nil {
-		for _, r := range *proxyConf.Retrievers {
-			currentRetriever, err := initRetriever(&r)
-			if err != nil {
-				return nil, err
-			}
-			retrievers = append(retrievers, currentRetriever)
-		}
+	retrievers, err := initRetrievers(proxyConf)
+	if err != nil {
+		return nil, err
 	}
 
-	var exp ffclient.DataExporter
-	if proxyConf.Exporter != nil {
-		exp, err = initDataExporter(proxyConf.Exporter)
-		if err != nil {
-			return nil, err
-		}
+	exporters, err := initDataExporters(proxyConf)
+	if err != nil {
+		return nil, err
 	}
 
 	notif, err := initNotifier(proxyConf.Notifiers)
@@ -91,11 +72,10 @@ func NewGoFeatureFlagClient(
 		PollingInterval:                 time.Duration(proxyConf.PollingInterval) * time.Millisecond,
 		LeveledLogger:                   slog.New(slogzap.Option{Level: slog.LevelDebug, Logger: logger}.NewZapHandler()),
 		Context:                         context.Background(),
-		Retriever:                       mainRetriever,
 		Retrievers:                      retrievers,
 		Notifiers:                       notif,
 		FileFormat:                      proxyConf.FileFormat,
-		DataExporter:                    exp,
+		DataExporters:                   exporters,
 		StartWithRetrieverError:         proxyConf.StartWithRetrieverError,
 		EnablePollingJitter:             proxyConf.EnablePollingJitter,
 		DisableNotifierOnInit:           proxyConf.DisableNotifierOnInit,
@@ -106,6 +86,29 @@ func NewGoFeatureFlagClient(
 	return ffclient.New(f)
 }
 
+// initRetrievers initialize the retrievers based on the configuration
+// it handles both the `retriever` and `retrievers` fields
+func initRetrievers(proxyConf *config.Config) ([]retriever.Retriever, error) {
+	retrievers := make([]retriever.Retriever, 0)
+	if proxyConf.Retriever != nil {
+		currentRetriever, err := initRetriever(proxyConf.Retriever)
+		if err != nil {
+			return nil, err
+		}
+		retrievers = append(retrievers, currentRetriever)
+	}
+	if proxyConf.Retrievers != nil {
+		for _, r := range *proxyConf.Retrievers {
+			currentRetriever, err := initRetriever(&r)
+			if err != nil {
+				return nil, err
+			}
+			retrievers = append(retrievers, currentRetriever)
+		}
+	}
+	return retrievers, nil
+}
+
 // initRetriever initialize the retriever based on the configuration
 func initRetriever(c *config.RetrieverConf) (retriever.Retriever, error) {
 	retrieverTimeout := config.DefaultRetriever.Timeout
@@ -200,6 +203,29 @@ func initRetriever(c *config.RetrieverConf) (retriever.Retriever, error) {
 	}
 }
 
+// initDataExporters initialize the exporters based on the configuration
+// it handles both the `exporter` and `exporters` fields.
+func initDataExporters(proxyConf *config.Config) ([]ffclient.DataExporter, error) {
+	exporters := make([]ffclient.DataExporter, 0)
+	if proxyConf.Exporter != nil {
+		exp, err := initDataExporter(proxyConf.Exporter)
+		if err != nil {
+			return nil, err
+		}
+		exporters = append(exporters, exp)
+	}
+	if proxyConf.Exporters != nil {
+		for _, e := range *proxyConf.Exporters {
+			currentExporter, err := initDataExporter(&e)
+			if err != nil {
+				return nil, err
+			}
+			exporters = append(exporters, currentExporter)
+		}
+	}
+	return exporters, nil
+}
+
 func initDataExporter(c *config.ExporterConf) (ffclient.DataExporter, error) {
 	dataExp := ffclient.DataExporter{
 		FlushInterval: func() time.Duration {