Go Provider

Get Started

An OpenFeature Provider is a pluggable integration layer that connects the OpenFeature SDK to a specific feature flag management system (e.g., VWO or custom in-house solutions). OpenFeature is an open-source standard for feature flagging, designed to provide a vendor-agnostic approach, enabling organizations to switch between feature flagging tools without rewriting application code.

This VWO OpenFeature Provider for Go helps you integrate Feature Experimentation systems into your Go-based applications.

GitHub Repo

Check this out

OpenFeature Ecosystem

Check this out

OpenFeature Docs

Check this out

🚧
Note
This library is intended to be used in server-side contexts and has not been evaluated for use on mobile devices.

Requirements

Go 1.24

SDK Installation

go get github.com/wingify/vwo-openfeature-provider-go

Usage

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/open-feature/go-sdk/openfeature"
    vwo "github.com/wingify/vwo-openfeature-provider-go/pkg"
)

func main() {
    provider, err := vwo.NewVWOProviderWithConfig(map[string]interface{}{
        "sdkKey":    "<your-vwo-sdk-key>",
        "accountId": "<your-vwo-account-id>",
    })
    if err != nil {
        log.Fatalf("Failed to create VWO feature provider: %v", err)
    }

    openfeature.SetProviderAndWait(provider)
    client := openfeature.NewClient("my-app")

    // Evaluate a boolean flag. If no variableKey is provided, this returns flag enabled/disabled.
    ctx := openfeature.NewEvaluationContext("unique-user-id", map[string]any{"variableKey": "booleanVariableKey"})
    enabled, err := client.BooleanValue(context.Background(), "featureKey", false, ctx)
    if err != nil {
        log.Fatalf("Failed to get boolean value: %v", err)
    }
    fmt.Println("Enabled:", enabled)

    // Evaluate typed variables by passing variableKey in the evaluation context
    // String variable
    ctx = openfeature.NewEvaluationContext("unique-user-id", map[string]any{"variableKey": "stringVariableKey"})
    strVal, _ := client.StringValue(context.Background(), "featureKey", "default", ctx)
    fmt.Println("String value:", strVal)

    // Integer variable
    ctx = openfeature.NewEvaluationContext("unique-user-id", map[string]any{"variableKey": "integerVariableKey"})
    intVal, _ := client.IntValue(context.Background(), "featureKey", 0, ctx)
    fmt.Println("Int value:", intVal)

    // Float variable
    ctx = openfeature.NewEvaluationContext("unique-user-id", map[string]any{"variableKey": "floatVariableKey"})
    floatVal, _ := client.FloatValue(context.Background(), "featureKey", 0.0, ctx)
    fmt.Println("Float value:", floatVal)

    // JSON variable
    ctx = openfeature.NewEvaluationContext("unique-user-id", map[string]any{"variableKey": "jsonVariableKey"})
    jsonVal, _ := client.ObjectValue(context.Background(), "featureKey", map[string]any{}, ctx)
    fmt.Println("JSON value:", jsonVal)
}

API Details

API	Arguments	Argument Description	API Description
`vwo.NewVWOProviderWithConfig(config)`	`config: map[string]interface{}`	config: Configuration object containing: `sdkKey` your VWO SDK key and `accountId`your VWO account ID	Creates a new instance of `VWOProvider`, enabling integration of VWO with OpenFeature in Go.
`openfeature.SetProviderAndWait(provider)`	`provider` (instance of `VWOProvider`)	provider: The VWO provider instance responsible for flag evaluations.	Registers the VWO provider with OpenFeature and waits until it is ready.
`openfeature.NewClient(name)`	`name: string`	name: A logical application or client name.	Creates a new OpenFeature client used to evaluate feature flags.
`openfeature.NewEvaluationContext(userID, attributes)`	`userID: string` `attributes: map[string]any`	userID: Unique identifier for the user. attributes: Additional data (e.g., `{ "variableKey": "stringVariableKey" }`)	Defines the evaluation context for feature flag resolution. Pass `variableKey` in attributes to fetch a specific variable.
`client.BooleanValue(ctx, featureKey, defaultValue, evalCtx)`	`ctx: context.Context, featureKey: string, defaultValue: bool, evalCtx: EvaluationContext`	featureKey: The feature flag key. defaultValue: Returned if evaluation fails. evalCtx: Must include `variableKey` to fetch a variable; otherwise returns feature ON/OFF.	Fetches the boolean value of a feature flag. Without `variableKey`, evaluates flag enabled/disabled.
`client.StringValue(ctx, featureKey, defaultValue, evalCtx)`	`featureKey: string`, `defaultValue: string`, `evalCtx: EvaluationContext`	evalCtx must contain `variableKey` to return a string variable.	Returns the string variable value. Without `variableKey`, returns the default value.
`client.IntValue(ctx, featureKey, defaultValue, evalCtx)`	`featureKey: string`, `defaultValue: int64`, `evalCtx: EvaluationContext`	evalCtx must contain `variableKey` to fetch a specific integer variable.	Fetches an integer variable value. Without `variableKey`, returns the default.
`client.FloatValue(ctx, featureKey, defaultValue, evalCtx)`	`featureKey: string`, `defaultValue: float64`, `evalCtx: EvaluationContext`	evalCtx must include `variableKey` to get the numeric variable.	Fetches a floating-point variable. Without `variableKey`, returns the default.
`client.ObjectValue(ctx, featureKey, defaultValue, evalCtx)`	`featureKey: string`, `defaultValue: map[string]any`, `evalCtx: EvaluationContext`	evalCtx may contain `variableKey` to fetch a specific JSON variable.	Fetches JSON variable values. If `variableKey` is provided, returns that variable's value.