feat(openfeature): server-side EVP flagevaluation emission

internal/env/supported_configurations.json

@@ -413,6 +413,13 @@
         "default": null
       }
     ],
+    "DD_FLAGGING_EVALUATION_COUNTS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_GIT_BRANCH": [
       {
         "implementation": "A",

openfeature/evaluator.go

@@ -34,9 +34,12 @@ type evaluationResult struct {
 	Metadata map[string]any
 }
 
-// evaluateFlag evaluates a feature flag with the given context.
+// evaluateFlag evaluates a feature flag with the given context. The caller supplies the
+// evaluation time (now) so a single timestamp is shared between the allocation time-window
+// checks here and the EVP eval-time metadata stamped by DatadogProvider.evaluate — avoiding a
+// second time.Now() on the evaluation path.
 // It returns the variant value, reason, and any error that occurred.
-func evaluateFlag(flag *flag, defaultValue any, context map[string]any) evaluationResult {
+func evaluateFlag(flag *flag, defaultValue any, context map[string]any, now time.Time) evaluationResult {
 	if flag == nil {
 		return evaluationResult{Value: defaultValue, Reason: of.DefaultReason}
 	}
@@ -48,8 +51,7 @@ func evaluateFlag(flag *flag, defaultValue any, context map[string]any) evaluati
 		}
 	}
 
-	// Evaluate allocations in order - first match wins
-	now := time.Now()
+	// Evaluate allocations in order - first match wins (using the caller-supplied eval time)
 	for _, allocation := range flag.Allocations {
 		split, matched, err := evaluateAllocation(allocation, context, now)
 		if err != nil {
@@ -80,7 +82,7 @@ func evaluateFlag(flag *flag, defaultValue any, context map[string]any) evaluati
 			}
 
 			// Build metadata for exposure tracking
-			metadata := make(map[string]any)
+			metadata := make(map[string]any, 3)
 			metadata[metadataAllocationKey] = allocation.Key
 
 			// Get doLog value (defaults to true if not specified)

openfeature/evaluator_test.go

@@ -703,7 +703,7 @@ func TestEvaluateFlag_VariantTypeMismatchReturnsParseError(t *testing.T) {
 				},
 			}
 
-			result := evaluateFlag(flag, nil, map[string]any{"targetingKey": "user-123"})
+			result := evaluateFlag(flag, nil, map[string]any{"targetingKey": "user-123"}, time.Now())
 
 			if result.Reason != of.ErrorReason {
 				t.Errorf("expected ErrorReason, got %s", result.Reason)
@@ -768,7 +768,7 @@ func TestEvaluateFlag_JSONFixtures(t *testing.T) {
 						ctx["targetingKey"] = *tc.TargetingKey
 					}
 
-					result := evaluateFlag(cfg.Flags[tc.Flag], tc.DefaultValue, ctx)
+					result := evaluateFlag(cfg.Flags[tc.Flag], tc.DefaultValue, ctx, time.Now())
 
 					if fmt.Sprintf("%v", result.Value) != fmt.Sprintf("%v", tc.Result.Value) {
 						t.Errorf("value: got %v, want %v", result.Value, tc.Result.Value)

openfeature/evp.go

@@ -0,0 +1,81 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2025 Datadog, Inc.
+
+package openfeature
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+
+	jsoniter "github.com/json-iterator/go"
+
+	"github.com/DataDog/dd-trace-go/v2/internal"
+	"github.com/DataDog/dd-trace-go/v2/internal/log"
+)
+
+type evpClient struct {
+	httpClient *http.Client
+	agentURL   *url.URL
+	jsonConfig jsoniter.API
+}
+
+func newEVPClient() *evpClient {
+	agentURL := internal.AgentURLFromEnv()
+	var httpClient *http.Client
+	if agentURL.Scheme == "unix" {
+		httpClient = internal.UDSClient(agentURL.Path, defaultHTTPTimeout)
+		agentURL = internal.UnixDataSocketURL(agentURL.Path)
+	} else {
+		httpClient = internal.DefaultHTTPClient(defaultHTTPTimeout, false)
+	}
+
+	return &evpClient{
+		httpClient: httpClient,
+		agentURL:   agentURL,
+		jsonConfig: jsoniter.Config{}.Froze(),
+	}
+}
+
+func (c *evpClient) post(endpoint, eventName string, payload any) error {
+	if c == nil {
+		return fmt.Errorf("EVP client is not configured")
+	}
+
+	var bytesBuffer bytes.Buffer
+	encoder := c.jsonConfig.NewEncoder(&bytesBuffer)
+	if err := encoder.Encode(payload); err != nil {
+		return fmt.Errorf("failed to encode %s payload: %w", eventName, err)
+	}
+
+	u := *c.agentURL
+	u.Path = endpoint
+	requestURL := u.String()
+
+	req, err := http.NewRequestWithContext(context.Background(), "POST", requestURL, &bytesBuffer)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set(evpSubdomainHeader, evpSubdomainValue)
+
+	log.Debug("openfeature: sending %s events to %s", eventName, requestURL)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 256))
+		return fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, string(body))
+	}
+	return nil
+}

openfeature/exposure.go

@@ -6,22 +6,13 @@
 package openfeature
 
 import (
-	"bytes"
 	"cmp"
 	"container/list"
-	"context"
-	"fmt"
-	"io"
 	"log/slog"
-	"net/http"
-	"net/url"
 	"os"
 	"sync"
 	"time"
 
-	jsoniter "github.com/json-iterator/go"
-
-	"github.com/DataDog/dd-trace-go/v2/internal"
 	"github.com/DataDog/dd-trace-go/v2/internal/env"
 	"github.com/DataDog/dd-trace-go/v2/internal/globalconfig"
 	"github.com/DataDog/dd-trace-go/v2/internal/log"
@@ -176,36 +167,27 @@ type exposureWriter struct {
 	buffer        []exposureEvent   // Buffer for exposure events
 	cache         *exposureLRUCache // LRU deduplication cache
 	flushInterval time.Duration
-	httpClient    *http.Client
-	agentURL      *url.URL
+	evp           *evpClient
 	context       exposureContext
 	ticker        *time.Ticker
 	stopChan      chan struct{}
 	stopped       bool
-	jsonConfig    jsoniter.API
 }
 
 // newExposureWriter creates a new exposure writer with the given configuration
 func newExposureWriter(config ProviderConfig) *exposureWriter {
-	agentURL := internal.AgentURLFromEnv()
-	var httpClient *http.Client
-	if agentURL.Scheme == "unix" {
-		httpClient = internal.UDSClient(agentURL.Path, defaultHTTPTimeout)
-		agentURL = internal.UnixDataSocketURL(agentURL.Path)
-	} else {
-		httpClient = internal.DefaultHTTPClient(defaultHTTPTimeout, false)
-	}
+	return newExposureWriterWithEVP(config, newEVPClient())
+}
 
+func newExposureWriterWithEVP(config ProviderConfig, evp *evpClient) *exposureWriter {
 	executable, _ := os.Executable()
 
 	return &exposureWriter{
 		buffer:        make([]exposureEvent, 0, 1<<8), // Initial capacity of 256
 		cache:         newExposureLRUCache(defaultExposureCacheCapacity),
 		flushInterval: cmp.Or(config.ExposureFlushInterval, defaultExposureFlushInterval),
-		httpClient:    httpClient,
-		agentURL:      agentURL,
+		evp:           evp,
 		stopChan:      make(chan struct{}),
-		jsonConfig:    jsoniter.Config{}.Froze(),
 		context: exposureContext{
 			Service: cmp.Or(env.Get("DD_SERVICE"), globalconfig.ServiceName(), executable),
 			Version: env.Get("DD_VERSION"),
@@ -298,44 +280,7 @@ func (w *exposureWriter) flush() {
 
 // sendToAgent sends the exposure payload to the Datadog Agent via EVP proxy
 func (w *exposureWriter) sendToAgent(payload exposurePayload) error {
-	// Serialize payload
-	var bytesBuffer bytes.Buffer
-	encoder := w.jsonConfig.NewEncoder(&bytesBuffer)
-	if err := encoder.Encode(payload); err != nil {
-		return fmt.Errorf("failed to encode exposure payload: %w", err)
-	}
-
-	// Build request URL
-	u := *w.agentURL
-	u.Path = exposureEndpoint
-	requestURL := u.String()
-
-	// Create HTTP request
-	req, err := http.NewRequestWithContext(context.Background(), "POST", requestURL, &bytesBuffer)
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-
-	// Set headers
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set(evpSubdomainHeader, evpSubdomainValue)
-
-	log.Debug("openfeature: sending exposure events to %s", requestURL)
-
-	// Send request
-	resp, err := w.httpClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	// Check response status
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 256))
-		return fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, string(body))
-	}
-
-	return nil
+	return w.evp.post(exposureEndpoint, "exposure", payload)
 }
 
 // stop stops the exposure writer and flushes any remaining events

openfeature/exposure_hook.go

@@ -19,6 +19,9 @@ const (
 	// Metadata keys for exposure tracking
 	metadataAllocationKey = "dd.allocation.key"
 	metadataDoLogKey      = "dd.doLog"
+	// metadataEvalTimeKey carries the evaluation timestamp (UnixMilli, int64). It is stamped in
+	// DatadogProvider.evaluate at evaluation entry so EVP first/last bounds use eval-time.
+	metadataEvalTimeKey = "dd.eval.timestamp_ms"
 )
 
 // exposureHook implements the OpenFeature Hook interface to track feature flag exposures.