some tests

Author: andreas-karlsson

openfeature-provider/go/confidence/integration_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"log/slog"
 	"os"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -685,6 +686,74 @@ func TestIntegration_OpenFeatureObjectWithStructDefault(t *testing.T) {
 	openfeature.Shutdown()
 }
 
+func TestIntegration_GetPrometheusMetrics(t *testing.T) {
+	// Load test state
+	testState := tu.LoadTestResolverState(t)
+	accountID := tu.LoadTestAccountID(t)
+
+	ctx := context.Background()
+
+	// Create mock state provider
+	stateProvider := &mockStateProvider{
+		state: testState,
+	}
+
+	// Create tracking logger with actual GrpcWasmFlagLogger and mocked connection
+	mockStub := &mockGrpcStubForIntegration{
+		onCallReceived: make(chan struct{}, 100),
+	}
+	actualGrpcLogger := fl.NewGrpcWasmFlagLogger(mockStub, "mkjJruAATQWjeY7foFIWfVAcBWnci2YF", slog.New(slog.NewTextHandler(os.Stderr, nil)))
+
+	trackingLogger := &trackingFlagLogger{
+		actualLogger:       actualGrpcLogger,
+		lastWriteCompleted: make(chan struct{}, 1),
+	}
+
+	// Create provider with test state
+	provider, err := createProviderWithTestState(ctx, stateProvider, accountID, trackingLogger, newUnsupportedMaterializationStore())
+	if err != nil {
+		t.Fatalf("Failed to create provider: %v", err)
+	}
+
+	// Register with OpenFeature
+	err = openfeature.SetProviderAndWait(provider)
+	if err != nil {
+		t.Fatalf("Failed to set provider: %v", err)
+	}
+
+	client := openfeature.NewClient("prometheus-metrics-test")
+
+	evalCtx := openfeature.NewEvaluationContext(
+		"tutorial_visitor",
+		map[string]interface{}{
+			"visitor_id": "tutorial_visitor",
+		},
+	)
+
+	// Resolve a flag to generate telemetry
+	result, _ := client.ObjectValueDetails(ctx, "tutorial-feature", map[string]interface{}{}, evalCtx)
+	t.Logf("Flag evaluation result: %+v", result)
+
+	// Get Prometheus metrics
+	metrics, err := provider.GetPrometheusMetrics()
+	if err != nil {
+		t.Fatalf("GetPrometheusMetrics() returned error: %v", err)
+	}
+
+	if metrics == "" {
+		t.Fatal("GetPrometheusMetrics() returned empty string, expected metrics output")
+	}
+
+	if !strings.Contains(metrics, "confidence_resolve_latency") {
+		t.Errorf("Expected metrics to contain 'confidence_resolve_latency', got:\n%s", metrics)
+	}
+
+	t.Logf("Prometheus metrics output:\n%s", metrics)
+
+	// Cleanup
+	openfeature.Shutdown()
+}
+
 // createProviderWithTestState creates a provider with mock state provider and tracking logger
 func createProviderWithTestState(
 	ctx context.Context,

openfeature-provider/java/src/test/java/com/spotify/confidence/sdk/OpenFeatureLocalResolveProviderIntegrationTest.java

@@ -287,6 +287,25 @@ void testShutdownSendsAllLogData() throws Exception {
         .isGreaterThanOrEqualTo(numThreads * resolutionsPerThread);
   }
 
+  @Test
+  void testGetPrometheusMetrics() throws Exception {
+    provider.initialize(new ImmutableContext());
+
+    // Resolve a flag to generate telemetry data
+    final ImmutableContext context =
+        new ImmutableContext(
+            "tutorial_visitor", Map.of("visitor_id", new Value("tutorial_visitor")));
+    provider.getObjectEvaluation("tutorial-feature", new Value("default"), context);
+
+    // Retrieve Prometheus metrics
+    final String metrics = provider.getPrometheusMetrics();
+
+    // Verify metrics are present and contain expected metric names
+    assertThat(metrics).isNotNull();
+    assertThat(metrics).isNotEmpty();
+    assertThat(metrics).contains("confidence_resolve_latency");
+  }
+
   @Nested
   class WithOpenFeatureApis {
 

openfeature-provider/js/src/ConfidenceServerProviderLocal.test.ts

@@ -466,3 +466,16 @@ describe('SDK telemetry', () => {
     );
   });
 });
+
+describe('getPrometheusMetrics', () => {
+  it('calls prometheusSnapshot on the resolver and returns the result', async () => {
+    await advanceTimersUntil(expect(provider.initialize()).resolves.toBeUndefined());
+
+    mockedWasmResolver.prometheusSnapshot.mockReturnValue('# HELP some_metric\nsome_metric 42\n');
+
+    const result = provider.getPrometheusMetrics();
+
+    expect(mockedWasmResolver.prometheusSnapshot).toHaveBeenCalledWith('0');
+    expect(result).toBe('# HELP some_metric\nsome_metric 42\n');
+  });
+});

openfeature-provider/python/tests/test_provider.py

@@ -795,3 +795,47 @@ def test_returns_default_on_error(
             assert result.reason == Reason.ERROR
         finally:
             provider.shutdown()
+
+
+class TestPrometheusMetrics:
+    """Tests for Prometheus metrics export."""
+
+    def test_get_prometheus_metrics(
+        self,
+        wasm_bytes: bytes,
+        test_resolver_state: bytes,
+        test_account_id: str,
+        test_client_secret: str,
+    ) -> None:
+        """Test that get_prometheus_metrics returns metrics after resolution."""
+        mock_fetcher = MockStateFetcher(test_resolver_state, test_account_id)
+        mock_logger = MockFlagLogger()
+
+        provider = ConfidenceProvider(
+            client_secret=test_client_secret,
+            state_fetcher=mock_fetcher,
+            flag_logger=mock_logger,
+            wasm_bytes=wasm_bytes,
+        )
+
+        provider.initialize(EvaluationContext())
+
+        try:
+            # Resolve a flag to generate telemetry
+            ctx = EvaluationContext(
+                targeting_key="test-user",
+                attributes={"visitor_id": "tutorial_visitor"},
+            )
+            provider.resolve_string_details(
+                flag_key="tutorial-feature.message",
+                default_value="default-message",
+                evaluation_context=ctx,
+            )
+
+            metrics = provider.get_prometheus_metrics()
+
+            assert isinstance(metrics, str)
+            assert len(metrics) > 0
+            assert "confidence_resolve_latency" in metrics
+        finally:
+            provider.shutdown()