featureflag

Overview ¶

Package featureflag provides a tracing-aware decorator around the OpenFeature Go SDK configured to use Flipt as its provider.

The Client mirrors the OpenFeature client's value-details methods (Client.BooleanValueDetails, Client.StringValueDetails) so callers have full access to resolution metadata (variant, reason, error code, flag metadata). The only addition is optional OTel tracing: when a [Config.Tracer] is set, every evaluation is recorded as a child span.

Setup ¶

The Flipt server address is configured via the FEATURE_FLAG_ENDPOINT environment variable:

export FEATURE_FLAG_ENDPOINT=http://flipt:8080

Use New in production code to pick up the endpoint automatically:

client, err := featureflag.New(ctx)
if err != nil {
	return err
}

Use NewWithConfig when the endpoint or namespace must be supplied programmatically:

client, err := featureflag.NewWithConfig(ctx, &featureflag.Config{
	Endpoint:  "http://localhost:8080",
	Namespace: "my-service",
})

Evaluating flags ¶

Client.BooleanValueDetails and Client.StringValueDetails evaluate a flag and return the full openfeature.BooleanEvaluationDetails or openfeature.StringEvaluationDetails together with any provider error:

details, err := client.BooleanValueDetails(ctx, "enable-new-api", false, openfeature.EvaluationContext{})
if err != nil {
	// defaultValue (false) is returned; log or handle the error.
}
if details.Value {
	// new API path
}

details, err := client.StringValueDetails(ctx, "ui-theme", "light", openfeature.EvaluationContext{})

Observability ¶

When a [Config.Tracer] is provided, every flag evaluation is instrumented with an OpenTelemetry child span carrying the following attributes:

• feature_flag.key - the flag key
• feature_flag.value - the resolved value
• feature_flag.variant - the matched variant name
• feature_flag.reason - the reason returned by the provider

Errors are recorded on the span via RecordError so the failure is visible in traces.

Testing ¶

Use memprovider.NewInMemoryProvider via [Config.Provider] to test flag evaluation without a running Flipt server:

import "github.com/open-feature/go-sdk/openfeature/memprovider"

provider := memprovider.NewInMemoryProvider(map[string]memprovider.InMemoryFlag{
	"my-flag": {
		Key:            "my-flag",
		State:          memprovider.Enabled,
		DefaultVariant: "on",
		Variants:       map[string]any{"on": true, "off": false},
	},
})

client, _ := featureflag.NewWithConfig(ctx, &featureflag.Config{
	Name:     "test",
	Provider: provider,
})

details, _ := client.BooleanValueDetails(ctx, "my-flag", false, openfeature.EvaluationContext{})
// details.Value == true
// details.Variant == "on"

package main

import (
	"context"
	"fmt"

	"github.com/open-feature/go-sdk/openfeature"
	"github.com/open-feature/go-sdk/openfeature/memprovider"
	"gitlab.com/gitlab-org/labkit/v2/featureflag"
)

func main() {
	provider := memprovider.NewInMemoryProvider(map[string]memprovider.InMemoryFlag{
		"enable-new-api": {
			Key:            "enable-new-api",
			State:          memprovider.Enabled,
			DefaultVariant: "on",
			Variants:       map[string]any{"on": true, "off": false},
		},
	})

	client, err := featureflag.NewWithConfig(context.Background(), &featureflag.Config{
		Name:     "example",
		Provider: provider,
	})
	if err != nil {
		panic(err)
	}
	defer func() {
		if err := client.Shutdown(context.Background()); err != nil {
			panic(err)
		}
	}()

	details, err := client.BooleanValueDetails(context.Background(), "enable-new-api", false, openfeature.EvaluationContext{})
	if err != nil {
		panic(err)
	}
	fmt.Println(details.Value)
}

Output:
true