Go SDK

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
)
8
9
func main() {
10
	err := unleash.Initialize(
11
		unleash.WithAppName("my-go-service"),
12
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
13
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
14
	)
15
16
	if err != nil {
17
		panic(err)
18
	}
19
20
	defer unleash.Close()
21
}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
)
8
9
func main() {
10
	err := unleash.Initialize(
11
		unleash.WithAppName("my-go-service"),
12
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
13
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
14
	)
15
16
	if err != nil {
17
		panic(err)
18
	}
19
	unleash.WaitForReady()
20
}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
)
8
9
func main() {
10
11
	err := unleash.Initialize(
12
		unleash.WithAppName("my-go-service"),
13
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
14
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
15
	)
16
	if err != nil {
17
		panic(err)
18
	}
19
20
	enabled := unleash.IsEnabled("my-feature", unleash.FeatureOptions{})
21
	if enabled {
22
		// new behavior
23
	}
24
}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
	unleashcontext "github.com/Unleash/unleash-go-sdk/v6/context"
8
)
9
10
func main() {
11
12
	err := unleash.Initialize(
13
		unleash.WithAppName("my-go-service"),
14
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
15
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
16
	)
17
	if err != nil {
18
		panic(err)
19
	}
20
21
	enabled := unleash.IsEnabled("my-feature", unleash.FeatureOptions{
22
		FallbackFunc: func(feature string, _ *unleashcontext.Context) bool {
23
			return true
24
		},
25
	})
26
27
	if enabled {
28
		// New behaviour
29
	}
30
}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
)
8
9
func main() {
10
	err := unleash.Initialize(
11
		unleash.WithAppName("my-go-service"),
12
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
13
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
14
	)
15
	if err != nil {
16
		panic(err)
17
	}
18
	defer unleash.Close()
19
20
	variant := unleash.GetVariant("checkout-experiment", unleash.VariantOptions{})
21
	if variant.Name == "blue" {
22
		// blue variant behavior
23
	} else if variant.Name == "green" {
24
		// green variant behavior
25
	}
26
}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
	"github.com/Unleash/unleash-go-sdk/v6/api"
8
	unleashcontext "github.com/Unleash/unleash-go-sdk/v6/context"
9
)
10
11
func main() {
12
	err := unleash.Initialize(
13
		unleash.WithAppName("my-go-service"),
14
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
15
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
16
	)
17
	if err != nil {
18
		panic(err)
19
	}
20
	defer unleash.Close()
21
22
	fallbackVariant := &api.Variant{
23
		Name:           "fallback",
24
		Enabled:        true,
25
		FeatureEnabled: true,
26
		Payload: api.Payload{
27
			Type:  "string",
28
			Value: "default",
29
		},
30
	}
31
32
	variant := unleash.GetVariant("checkout-experiment", unleash.VariantOptions{
33
		VariantFallbackFunc: func(feature string, _ *unleashcontext.Context) *api.Variant {
34
			if feature == "checkout-experiment" {
35
				return fallbackVariant
36
			}
37
			return api.GetDefaultVariant()
38
		},
39
	})
40
41
	if variant.Enabled {
42
		// use variant.Name and variant.Payload
43
	}
44
}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
	unleashcontext "github.com/Unleash/unleash-go-sdk/v6/context"
8
)
9
10
func main() {
11
	err := unleash.Initialize(
12
		unleash.WithAppName("my-go-service"),
13
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
14
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
15
	)
16
	if err != nil {
17
		panic(err)
18
	}
19
	defer unleash.Close()
20
21
	ctx := unleashcontext.Context{
22
		UserId:    "user-123",
23
		SessionId: "session-abc",
24
		Properties: map[string]string{
25
			"plan": "enterprise",
26
		},
27
	}
28
29
	enabled := unleash.IsEnabled("my-feature", unleash.FeatureOptions{Ctx: ctx})
30
	variant := unleash.GetVariant("checkout-experiment", unleash.VariantOptions{Ctx: ctx})
31
32
	_ = enabled
33
    enabled := unleash.IsEnabled("my-feature", unleash.FeatureOptions{Ctx: ctx})
34
	if enabled {
35
		// New behaviour
36
	}
37
38
	variant := unleash.GetVariant("checkout-experiment", unleash.VariantOptions{Ctx: ctx})
39
40
	if variant.flagEnabled {
41
		// checking variant name to pick New behaviour
42
	}
43
}

1
file, err := os.Open("bootstrap.json")
2
if err != nil {
3
	panic(err)
4
}
5
defer file.Close()
6
7
err = unleash.Initialize(
8
	unleash.WithAppName("my-go-service"),
9
	unleash.WithUrl("https://<your-unleash-instance>/api/"),
10
	unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
11
	unleash.WithStorage(&unleash.BootstrapStorage{Reader: file}),
12
)
13
if err != nil {
14
	panic(err)
15
}

1
package main
2
3
import (
4
	"encoding/json"
5
	"net/http"
6
	"os"
7
8
	unleash "github.com/Unleash/unleash-go-sdk/v6"
9
	"github.com/Unleash/unleash-go-sdk/v6/api"
10
)
11
12
type CustomBootstrapStorage struct {
13
	Backing       unleash.DefaultStorage
14
	BootstrapJSON []byte
15
}
16
17
func (s *CustomBootstrapStorage) Init(backupPath, appName string) {
18
	s.Backing.Init(backupPath, appName)
19
}
20
21
func (s *CustomBootstrapStorage) Load() (*api.FeatureResponse, error) {
22
	if len(s.BootstrapJSON) > 0 {
23
		var state api.FeatureResponse
24
		if err := json.Unmarshal(s.BootstrapJSON, &state); err == nil {
25
			return &state, nil
26
		}
27
	}
28
29
	// Fallback to persisted cache when bootstrap data is missing or invalid.
30
	return s.Backing.Load()
31
}
32
33
func (s *CustomBootstrapStorage) Persist(state *api.FeatureResponse) error {
34
	return s.Backing.Persist(state)
35
}
36
37
func main() {
38
	bootstrapJSON, err := os.ReadFile("bootstrap.json")
39
	if err != nil {
40
		panic(err)
41
	}
42
43
	err = unleash.Initialize(
44
		unleash.WithAppName("my-go-service"),
45
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
46
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
47
		unleash.WithStorage(&CustomBootstrapStorage{BootstrapJSON: bootstrapJSON}),
48
	)
49
	if err != nil {
50
		panic(err)
51
	}
52
	defer unleash.Close()
53
}

1
type MyListener struct{}
2
3
func (l *MyListener) OnError(err error)                     {}
4
func (l *MyListener) OnWarning(warning error)               {}
5
func (l *MyListener) OnReady()                              {}
6
func (l *MyListener) OnUpdate()                             {}
7
func (l *MyListener) OnCount(name string, enabled bool)     {}
8
func (l *MyListener) OnSent(payload unleash.MetricsData)    {}
9
func (l *MyListener) OnRegistered(payload unleash.ClientData) {}
10
func (l *MyListener) OnImpression(event unleash.ImpressionEvent) {}

1
package main
2
3
import (
4
	"net/http"
5
6
	unleash "github.com/Unleash/unleash-go-sdk/v6"
7
)
8
9
func main() {
10
	err := unleash.Initialize(
11
		unleash.WithAppName("my-go-service"),
12
		unleash.WithEnvironment("production"),
13
		unleash.WithUrl("https://<your-unleash-instance>/api/"),
14
		unleash.WithCustomHeaders(http.Header{"Authorization": {"<your-backend-token>"}}),
15
	)
16
	if err != nil {
17
		panic(err)
18
	}
19
	defer unleash.Close()
20
21
	unleash.DefineCounter("request_count", "Total number of HTTP requests")
22
	unleash.IncrementCounter("request_count")
23
24
	unleash.DefineGauge("active_users", "Current number of active users")
25
	unleash.UpdateGauge("active_users", 42)
26
27
	unleash.DefineHistogram(
28
		"request_time_ms",
29
		"Request processing time in milliseconds",
30
		50, 100, 200, 500, 1000,
31
	)
32
	unleash.ObserveHistogram("request_time_ms", 125)
33
}

1
package main
2
3
import (
4
	unleashcontext "github.com/Unleash/unleash-go-sdk/v6/context"
5
)
6
7
type EmailStrategy struct{}
8
9
func (s EmailStrategy) Name() string {
10
	return "ActiveForUserWithEmail"
11
}
12
func (s EmailStrategy) IsEnabled(params map[string]any, ctx *unleashcontext.Context) bool {
13
	if ctx == nil || ctx.Properties == nil {
14
		return false
15
	}
16
	return ctx.Properties["email"] == "user@example.com"
17
}

1
unleash.WithStrategies(&EmailStrategy{})

1
package mypkg_test
2
3
import (
4
	"testing"
5
	"time"
6
7
	unleash "github.com/Unleash/unleash-go-sdk/v6"
8
	"github.com/Unleash/unleash-go-sdk/v6/api"
9
)
10
11
type testStorage map[string]api.Feature
12
13
func (s testStorage) Init(string, string) {}
14
15
func (s testStorage) Load() (*api.FeatureResponse, error) {
16
	features := make([]api.Feature, 0, len(s))
17
	for _, f := range s {
18
		features = append(features, f)
19
	}
20
21
	return &api.FeatureResponse{
22
		Features: features,
23
		Segments: []api.Segment{},
24
	}, nil
25
}
26
27
func (s testStorage) Persist(*api.FeatureResponse) error { return nil }
28
29
func TestFlags(t *testing.T) {
30
	client, err := unleash.NewClient(
31
		unleash.WithAppName("test-app"),
32
		unleash.WithUrl("http://127.0.0.1:4242/api/"),
33
		unleash.WithDisableMetrics(true),
34
		unleash.WithRefreshInterval(24*time.Hour),
35
		unleash.WithStorage(testStorage{
36
			"my-feature": {
37
				Name:    "my-feature",
38
				Enabled: true,
39
				Strategies: []api.Strategy{
40
					{Name: "default"},
41
				},
42
				Variants: []api.VariantInternal{
43
					{
44
						Variant: api.Variant{
45
							Name:           "blue",
46
							Enabled:        true,
47
							FeatureEnabled: true,
48
						},
49
						Weight: 1000,
50
					},
51
				},
52
			},
53
		}),
54
	)
55
	if err != nil {
56
		t.Fatal(err)
57
	}
58
	defer client.Close()
59
60
	if !client.IsEnabled("my-feature", unleash.FeatureOptions{}) {
61
		t.Fatal("expected my-feature to be enabled")
62
	}
63
64
	variant := client.GetVariant("my-feature", unleash.VariantOptions{})
65
	if variant.Name != "blue" {
66
		t.Fatalf("expected variant blue, got %s", variant.Name)
67
	}
68
}