finished exposure writer work

Signed-off-by: Eliott Bouhana <[email protected]>

Author: eliottness

openfeature/doc.go

@@ -191,9 +191,47 @@
 // Configuration updates are acknowledged back to Remote Config with appropriate
 // status codes (acknowledged for success, error for validation failures).
 //
+// # Configuration
+//
+// The provider can be configured using ProviderConfig when creating a new instance:
+//
+//	config := openfeature.ProviderConfig{
+//	    ExposureFlushInterval: 5 * time.Second,  // Optional: defaults to 1 second
+//	}
+//	provider, err := openfeature.NewDatadogProvider(config)
+//
+// Configuration Options:
+//
+//   - ExposureFlushInterval: Duration between automatic flushes of exposure events
+//     to the Datadog agent. Defaults to 1 second if not specified. Exposure events
+//     track which feature flags are evaluated and by which users, providing visibility
+//     into feature flag usage. Set to 0 to disable automatic flushing (not recommended).
+//
+// # Environment Variables
+//
+// The provider requires the following environment variable to be set:
+//
+//   - DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED: Must be set to "true" to enable
+//     the OpenFeature provider. This is a safety flag to ensure the feature is
+//     intentionally activated. If not set or set to false, NewDatadogProvider()
+//     will return a NoopProvider instead of the actual Datadog provider.
+//
+// Example:
+//
+//	export DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true
+//
+// Standard Datadog environment variables also apply:
+//
+//   - DD_AGENT_HOST: Datadog agent host (default: localhost)
+//   - DD_TRACE_AGENT_PORT: Datadog agent port (default: 8126)
+//   - DD_SERVICE: Service name for tagging
+//   - DD_ENV: Environment name (e.g., production, staging)
+//   - DD_VERSION: Application version
+//
 // # Prerequisites
 //
 // Before creating the provider, ensure that:
+//   - DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED environment variable is set to "true"
 //   - The Datadog tracer is started (tracer.Start()) OR
 //   - Remote Config client is properly configured
 //

openfeature/exposure.go

@@ -74,7 +74,7 @@ type exposureSubject struct {
 
 // exposureContext represents service context metadata for the exposure payload
 type exposureContext struct {
-	ServiceName string `json:"service_name"`
+	ServiceName string `json:"service"`
 	Version     string `json:"version,omitempty"`
 	Env         string `json:"env,omitempty"`
 }
@@ -85,17 +85,10 @@ type exposurePayload struct {
 	Exposures []exposureEvent `json:"exposures"`
 }
 
-type bufferKey struct {
-	flagKey       string
-	allocationKey string
-	variantKey    string
-	subjectID     string
-}
-
 // exposureWriter manages buffering and flushing of exposure events to the Datadog Agent
 type exposureWriter struct {
 	mu            sync.Mutex
-	buffer        map[bufferKey]exposureEvent // Deduplicate by composite key
+	buffer        []exposureEvent // Buffer for exposure events
 	flushInterval time.Duration
 	httpClient    *http.Client
 	agentURL      *url.URL
@@ -143,7 +136,7 @@ func newExposureWriter(config ProviderConfig) *exposureWriter {
 	}
 
 	return &exposureWriter{
-		buffer:        make(map[bufferKey]exposureEvent),
+		buffer:        make([]exposureEvent, 0),
 		flushInterval: flushInterval,
 		httpClient:    httpClient,
 		agentURL:      agentURL,
@@ -167,7 +160,7 @@ func (w *exposureWriter) start() {
 	}()
 }
 
-// append adds an exposure event to the buffer with deduplication
+// append adds an exposure event to the buffer
 func (w *exposureWriter) append(event exposureEvent) {
 	w.mu.Lock()
 	defer w.mu.Unlock()
@@ -176,17 +169,9 @@ func (w *exposureWriter) append(event exposureEvent) {
 		return
 	}
 
-	// Create composite key for deduplication
-	// Deduplicate by flag, allocation, variant, and subject.id
-	key := bufferKey{
-		flagKey:       event.Flag.Key,
-		allocationKey: event.Allocation.Key,
-		variantKey:    event.Variant.Key,
-		subjectID:     event.Subject.ID,
-	}
-
-	// Store event (will overwrite if duplicate)
-	w.buffer[key] = event
+	// Append event to buffer
+	// Each exposure event is tracked individually to maintain accurate analytics
+	w.buffer = append(w.buffer, event)
 }
 
 // flush sends all buffered exposure events to the agent
@@ -198,11 +183,8 @@ func (w *exposureWriter) flush() {
 	}
 
 	// Move buffer to local variable and create new buffer
-	events := make([]exposureEvent, 0, len(w.buffer))
-	for _, event := range w.buffer {
-		events = append(events, event)
-	}
-	w.buffer = make(map[bufferKey]exposureEvent)
+	events := w.buffer
+	w.buffer = make([]exposureEvent, 0)
 	w.mu.Unlock()
 
 	// Build payload