chore(go): add some comments

Author: nicklasl

openfeature-provider/go/demo/main.go

@@ -73,7 +73,7 @@ func main() {
 		},
 	)
 
-	// Run 10 concurrent threads continuously for at least 20 seconds
+	// Run 20 concurrent threads continuously for at least 20 seconds
 	var wg sync.WaitGroup
 	numThreads := 20
 	runDuration := 20 * time.Second

openfeature-provider/go/local_resolver_factory.go

@@ -116,6 +116,8 @@ func NewLocalResolverFactory(
 		token, err := tokenHolder.GetToken(ctx)
 		if err != nil {
 			log.Printf("Warning: failed to get initial token, account name will be unknown: %v", err)
+			// TODO should we return an error here?
+			// return nil, fmt.Errorf("failed to get initial token: %w", err)
 		}
 		accountName := "unknown"
 		if token != nil {
@@ -127,9 +129,11 @@ func NewLocalResolverFactory(
 		stateProvider = stateFetcher
 
 		// Get initial state using StateProvider interface
-		initialState, err = stateFetcher.Provide(ctx)
+		initialState, err = stateProvider.Provide(ctx)
 		if err != nil {
 			log.Printf("Initial state fetch failed, using empty state: %v", err)
+			// TODO should we return an error here?
+			// return nil, fmt.Errorf("failed to get initial state: %w", err)
 		}
 		if initialState == nil {
 			initialState = []byte{}
@@ -190,10 +194,10 @@ func (f *LocalResolverFactory) startScheduledTasks(parentCtx context.Context) {
 		for {
 			select {
 			case <-ticker.C:
-				// Fetch latest state using StateProvider interface
+				// Fetch latest state
 				state, err := f.stateProvider.Provide(ctx)
 				if err != nil {
-					log.Printf("State fetch from provider failed: %v", err)
+					log.Printf("State fetch failed: %v", err)
 				}
 
 				// Update state and flush logs (even if state fetch failed, use cached state)

openfeature-provider/go/provider_builder.go

@@ -20,17 +20,20 @@ type ProviderConfig struct {
 	ClientSecret    string
 
 	// Optional: Custom service addresses (for advanced use cases only)
-	// If not provided, defaults to EU region
+	// If not provided, defaults to global region
 	ResolverStateServiceAddr string
 	FlagLoggerServiceAddr    string
 	AuthServiceAddr          string
-
-	// Optional: Custom WASM bytes (for advanced use cases only)
-	// If not provided, loads from default location
-	WasmBytes []byte
 }
 
 // ProviderConfigWithStateProvider holds configuration for the Confidence provider with a custom StateProvider
+// WARNING: This configuration is intended for testing and advanced use cases ONLY.
+// For production deployments, use NewProvider() with ProviderConfig instead, which provides:
+//   - Automatic state fetching from Confidence backend
+//   - Built-in authentication and secure connections
+//   - Exposure event logging for analytics
+//
+// Only use this when you need to provide a custom state source (e.g., local file cache for testing).
 type ProviderConfigWithStateProvider struct {
 	// Required: Client secret for signing evaluations
 	ClientSecret string
@@ -75,15 +78,10 @@ func NewProvider(ctx context.Context, config ProviderConfig) (*LocalResolverProv
 		authServiceAddr = ConfidenceDomain
 	}
 
-	// Load WASM bytes
-	wasmBytes := config.WasmBytes
-	if wasmBytes == nil {
-		// Load from default filesystem location
-		var err error
-		wasmBytes, err = os.ReadFile("../../../wasm/confidence_resolver.wasm")
-		if err != nil {
-			return nil, fmt.Errorf("failed to load WASM module from ../../wasm/confidence_resolver.wasm: %w. Please provide WasmBytes in config or ensure WASM file exists", err)
-		}
+	// Load wasm from default filesystem location
+	wasmBytes, err := os.ReadFile("../../../wasm/confidence_resolver.wasm")
+	if err != nil {
+		return nil, fmt.Errorf("failed to load WASM module from ../../../wasm/confidence_resolver.wasm: %w", err)
 	}
 
 	runtimeConfig := wazero.NewRuntimeConfig()
@@ -114,6 +112,7 @@ func NewProvider(ctx context.Context, config ProviderConfig) (*LocalResolverProv
 }
 
 // NewProviderWithStateProvider creates a new Confidence OpenFeature provider with a custom StateProvider
+// Should only be used for testing purposes. Will not emit exposure logging.
 func NewProviderWithStateProvider(ctx context.Context, config ProviderConfigWithStateProvider) (*LocalResolverProvider, error) {
 	// Validate required fields
 	if config.ClientSecret == "" {

openfeature-provider/go/resolver_api.go

@@ -171,7 +171,7 @@ func (r *ResolverApi) FlushLogs() error {
 		return nil
 	}
 
-	// Write logs via the flag logger if we have one
+	// Write logs via the flag logger
 	if r.flagLogger != nil && (len(logRequest.FlagAssigned) > 0 || len(logRequest.ClientResolveInfo) > 0 || len(logRequest.FlagResolveInfo) > 0) {
 		if err := r.flagLogger.Write(ctx, logRequest); err != nil {
 			log.Printf("Failed to write flushed logs: %v", err)

openfeature-provider/go/swap_wasm_resolver_api.go

@@ -74,7 +74,7 @@ func (s *SwapWasmResolverApi) UpdateStateAndFlushLogs(state []byte, accountId st
 	// Atomically swap to the new instance
 	oldInstance := s.currentInstance.Swap(newInstance).(*ResolverApi)
 
-	// Close the old instance
+	// Close the old instance (which flushes logs)
 	oldInstance.Close(ctx)
 	return nil
 }