feat(multi): implement Tracker interface and fix event handling

Implements the Tracker interface for the multi-provider to forward
tracking calls to all ready providers that support tracking.

Signed-off-by: Roman Dmytrenko <[email protected]>

Author: erka

openfeature/multi/multiprovider.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"maps"
 	"slices"
 	"strings"
 	"sync"
@@ -89,6 +90,7 @@ var (
 	_ of.FeatureProvider = (*Provider)(nil)
 	_ of.EventHandler    = (*Provider)(nil)
 	_ of.StateHandler    = (*Provider)(nil)
+	_ of.Tracker         = (*Provider)(nil)
 )
 
 // init Initialize "constants" used for event handling priorities and filtering.
@@ -380,10 +382,8 @@ func (p *Provider) Init(evalCtx of.EvaluationContext) error {
 			if eventer, ok := provider.(of.EventHandler); ok {
 				l.LogAttrs(context.Background(), slog.LevelDebug, "detected EventHandler implementation")
 				handlers <- namedEventHandler{eventer, name}
-			} else {
-				// Do not yet update providers that need event handling
-				p.updateProviderState(name, of.ReadyState)
 			}
+			p.updateProviderState(name, of.ReadyState)
 			return nil
 		})
 	}
@@ -566,3 +566,32 @@ func (p *Provider) setStatus(state of.State) {
 func (p *Provider) EventChannel() <-chan of.Event {
 	return p.outboundEvents
 }
+
+// Track implements the [of.Tracker] interface by forwarding tracking calls to all internal providers that
+// are in ready state and implement the [of.Tracker] interface.
+func (p *Provider) Track(ctx context.Context, trackingEventName string, evaluationContext of.EvaluationContext, details of.TrackingEventDetails) {
+	if !p.initialized {
+		// Don't do anything if we were never initialized
+		p.logger.LogAttrs(ctx, slog.LevelDebug, "provider not initialized, skipping tracking", slog.String("tracking-event", trackingEventName))
+		return
+	}
+	p.providerStatusLock.Lock()
+	data := maps.Clone(p.providerStatus)
+	p.providerStatusLock.Unlock()
+	for providerID, state := range data {
+		if state != of.ReadyState {
+			continue
+		}
+		provider, ok := p.providers[providerID]
+		if !ok {
+			p.logger.LogAttrs(ctx, slog.LevelWarn, "provider not found during tracking",
+				slog.String(MetadataProviderName, providerID),
+				slog.String("tracking-event", trackingEventName),
+			)
+			continue
+		}
+		if tracker, ok := provider.(of.Tracker); ok {
+			tracker.Track(ctx, trackingEventName, evaluationContext, details)
+		}
+	}
+}

openfeature/multi/multiprovider_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"regexp"
 	"testing"
-	"time"
 
 	of "github.com/open-feature/go-sdk/openfeature"
 	imp "github.com/open-feature/go-sdk/openfeature/memprovider"
@@ -359,29 +358,29 @@ func TestMultiProvider_StateUpdateWithSameTypeProviders(t *testing.T) {
 		"secondary": secondaryProvider,
 	}
 
-	multiProvider, err := NewProvider(providers, StrategyFirstMatch)
+	mp, err := NewProvider(providers, StrategyFirstMatch)
 	if err != nil {
 		t.Fatalf("failed to create multi-provider: %v", err)
 	}
-	t.Cleanup(multiProvider.Shutdown)
+	t.Cleanup(mp.Shutdown)
 
 	// Initialize the provider
 	ctx := of.NewEvaluationContext("test", nil)
-	if err := multiProvider.Init(ctx); err != nil {
+	if err := mp.Init(ctx); err != nil {
 		t.Fatalf("failed to initialize multi-provider: %v", err)
 	}
 
 	primaryProvider.EmitEvent(of.ProviderError, "fail to fetch data")
 	secondaryProvider.EmitEvent(of.ProviderReady, "rev 1")
-
-	time.Sleep(200 * time.Millisecond)
+	// wait for processing
+	<-mp.outboundEvents
 
 	// Check the state after the error event
-	multiProvider.providerStatusLock.Lock()
-	primaryState := multiProvider.providerStatus["primary"]
-	secondaryState := multiProvider.providerStatus["secondary"]
-	numProviders := len(multiProvider.providerStatus)
-	multiProvider.providerStatusLock.Unlock()
+	mp.providerStatusLock.Lock()
+	primaryState := mp.providerStatus["primary"]
+	secondaryState := mp.providerStatus["secondary"]
+	numProviders := len(mp.providerStatus)
+	mp.providerStatusLock.Unlock()
 
 	if primaryState != of.ErrorState {
 		t.Errorf("Expected primary-mock state to be ERROR after emitting error event, got %s", primaryState)
@@ -396,19 +395,150 @@ func TestMultiProvider_StateUpdateWithSameTypeProviders(t *testing.T) {
 	}
 }
 
+func TestMultiProvider_Track(t *testing.T) {
+	t.Run("forwards tracking to all ready providers that implement Tracker", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		t.Cleanup(ctrl.Finish)
+
+		provider1 := newMockProviderWithEvents(ctrl, "provider1")
+		provider2 := newMockProviderWithEvents(ctrl, "provider2")
+		provider3 := imp.NewInMemoryProvider(map[string]imp.InMemoryFlag{}) // Does not implement Tracker
+
+		providers := make(ProviderMap)
+		providers["provider1"] = provider1
+		providers["provider2"] = provider2
+		providers["provider3"] = provider3
+
+		mp, err := NewProvider(providers, StrategyFirstSuccess)
+		require.NoError(t, err)
+		t.Cleanup(mp.Shutdown)
+
+		evalCtx := of.NewEvaluationContext("user-123", map[string]any{"plan": "premium"})
+		err = mp.Init(evalCtx)
+		require.NoError(t, err)
+
+		trackingEventName := "button-clicked"
+		details := of.NewTrackingEventDetails(42.0).Add("currency", "USD")
+
+		ctx := t.Context()
+		// Expect Track to be called on providers that implement Tracker
+		provider1.MockTracker.EXPECT().Track(ctx, trackingEventName, evalCtx, details).Times(1)
+		provider2.MockTracker.EXPECT().Track(ctx, trackingEventName, evalCtx, details).Times(1)
+
+		mp.Track(ctx, trackingEventName, evalCtx, details)
+	})
+
+	t.Run("does not track when provider is not initialized", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		t.Cleanup(ctrl.Finish)
+
+		provider1 := newMockProviderWithEvents(ctrl, "provider1")
+		// manual shutdown on cleanup because multi-provider won't be initialized
+		t.Cleanup(provider1.Shutdown)
+
+		providers := make(ProviderMap)
+		providers["provider1"] = provider1
+
+		mp, err := NewProvider(providers, StrategyFirstSuccess)
+		require.NoError(t, err)
+		t.Cleanup(mp.Shutdown)
+
+		// Don't initialize the multi-provider
+		ctx := context.Background()
+		trackingEventName := "button-clicked"
+		evalCtx := of.NewEvaluationContext("user-123", map[string]any{})
+		details := of.TrackingEventDetails{}
+
+		// Should not call Track on provider
+		provider1.MockTracker.EXPECT().Track(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
+
+		mp.Track(ctx, trackingEventName, evalCtx, details)
+	})
+
+	t.Run("only tracks on providers in ready state", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		t.Cleanup(ctrl.Finish)
+
+		readyProvider := newMockProviderWithEvents(ctrl, "ready-provider")
+		errorProvider := newMockProviderWithEvents(ctrl, "error-provider")
+
+		providers := make(ProviderMap)
+		providers["ready-provider"] = readyProvider
+		providers["error-provider"] = errorProvider
+
+		mp, err := NewProvider(providers, StrategyFirstSuccess)
+		require.NoError(t, err)
+		t.Cleanup(mp.Shutdown)
+
+		evalCtx := of.NewEvaluationContext("user-456", map[string]any{})
+		err = mp.Init(evalCtx)
+		require.NoError(t, err)
+
+		// Simulate error state for one provider
+		errorProvider.eventChannel <- of.Event{
+			ProviderName: "error-provider",
+			EventType:    of.ProviderError,
+			ProviderEventDetails: of.ProviderEventDetails{
+				Message:       "error",
+				EventMetadata: make(map[string]any),
+			},
+		}
+		// wait for event processing
+		<-mp.outboundEvents
+
+		trackingEventName := "page-view"
+		details := of.TrackingEventDetails{}
+
+		ctx := t.Context()
+		readyProvider.MockTracker.EXPECT().Track(ctx, trackingEventName, evalCtx, details).Times(1)
+		errorProvider.MockTracker.EXPECT().Track(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
+
+		mp.Track(ctx, trackingEventName, evalCtx, details)
+	})
+
+	t.Run("handles providers that don't implement Tracker", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		t.Cleanup(ctrl.Finish)
+
+		trackerProvider := newMockProviderWithEvents(ctrl, "tracker-provider")
+		nonTrackerProvider := imp.NewInMemoryProvider(map[string]imp.InMemoryFlag{})
+
+		providers := make(ProviderMap)
+		providers["tracker-provider"] = trackerProvider
+		providers["non-tracker"] = nonTrackerProvider
+
+		mp, err := NewProvider(providers, StrategyFirstSuccess)
+		require.NoError(t, err)
+		t.Cleanup(mp.Shutdown)
+
+		evalCtx := of.NewEvaluationContext("user-789", map[string]any{})
+		err = mp.Init(evalCtx)
+		require.NoError(t, err)
+
+		trackingEventName := "conversion"
+		details := of.NewTrackingEventDetails(99.99)
+
+		ctx := t.Context()
+		trackerProvider.MockTracker.EXPECT().Track(ctx, trackingEventName, evalCtx, details).Times(1)
+		mp.Track(ctx, trackingEventName, evalCtx, details)
+	})
+}
+
 var _ of.StateHandler = (*mockProviderWithEvents)(nil)
 
-// mockProviderWithEvents wraps a mock provider to add EventHandler capability
+// mockProviderWithEvents wraps a mock provider to add EventHandler and optional Tracker capability
 type mockProviderWithEvents struct {
 	*of.MockFeatureProvider
 	*of.MockStateHandler
+	*of.MockTracker
 	eventChannel chan of.Event
 	metadata     of.Metadata
 }
 
 func newMockProviderWithEvents(ctrl *gomock.Controller, name string) *mockProviderWithEvents {
 	mockProvider := of.NewMockFeatureProvider(ctrl)
 	mockStateHandler := of.NewMockStateHandler(ctrl)
+	mockTracker := of.NewMockTracker(ctrl)
 	eventChan := make(chan of.Event, 10)
 
 	metadata := of.Metadata{Name: name}
@@ -434,6 +564,7 @@ func newMockProviderWithEvents(ctrl *gomock.Controller, name string) *mockProvid
 		MockStateHandler:    mockStateHandler,
 		eventChannel:        eventChan,
 		metadata:            metadata,
+		MockTracker:         mockTracker,
 	}
 }
 
@@ -460,3 +591,9 @@ func (m *mockProviderWithEvents) EmitEvent(eventType of.EventType, message strin
 		},
 	}
 }
+
+func (m *mockProviderWithEvents) Track(ctx context.Context, trackingEventName string, evaluationContext of.EvaluationContext, details of.TrackingEventDetails) {
+	if m.MockTracker != nil {
+		m.MockTracker.Track(ctx, trackingEventName, evaluationContext, details)
+	}
+}