const (
// DefaultURL is the default value for StoreBuilder.URL.
DefaultURL = "redis://localhost:6379"
// DefaultPrefix is the default value for StoreBuilder.Prefix.
DefaultPrefix = "launchdarkly"
)
Pool is an interface representing a Redis connection pool.
The methods of this interface are the same as the basic methods of the Pool type in the Redigo client. Any type implementing the interface can be passed to StoreBuilder.PoolInterface to provide custom connection behavior.
type Pool interface {
// Get obtains a Redis connection.
//
// See: https://pkg.go.dev/github.com/gomodule/redigo/redis#Pool.Get
Get() r.Conn
// Close releases the resources used by the pool.
//
// See: https://pkg.go.dev/github.com/gomodule/redigo/redis#Pool.Close
Close() error
}
StoreBuilder is a builder for configuring the Redis-based persistent data store and/or Big Segment store.
Both DataStore and BigSegmentStore return instances of this type. You can use methods of the builder to specify any ny non-default Redis options you may want, before passing the builder to either github.com/launchdarkly/go-server-sdk/v6/ldcomponents.PersistentDataStore or github.com/launchdarkly/go-server-sdk/v6/ldcomponents.BigSegments as appropriate. The two types of stores are independent of each other; you do not need a Big Segment store if you are not using the Big Segments feature, and you do not need to use the same database for both.
In this example, the main data store uses a Redis host called "host1", and the Big Segment store uses a Redis host called "host2":
config.DataStore = ldcomponents.PersistentDataStore(
ldredis.DataStore().URL("redis://host1:6379")
config.BigSegments = ldcomponents.BigSegments(
ldredis.DataStore().URL("redis://host2:6379")
Note that the SDK also has its own options related to data storage that are configured at a different level, because they are independent of what database is being used. For instance, the builder returned by github.com/launchdarkly/go-server-sdk/v6/ldcomponents.PersistentDataStore has options for caching:
config.DataStore = ldcomponents.PersistentDataStore(
ldredis.DataStore().HostAndPort("host1", 6379),
).CacheSeconds(15)
type StoreBuilder[T any] struct { // contains filtered or unexported fields }
func BigSegmentStore() *StoreBuilder[subsystems.BigSegmentStore]
BigSegmentStore returns a configurable builder for a Redis-backed Big Segment store.
You can use methods of the builder to specify any non-default Redis options you may want, before passing the builder to github.com/launchdarkly/go-server-sdk/v6/ldcomponents.BigSegments. In this example, the store is configured to use a Redis host called "host2":
config.BigSegments = ldcomponents.BigSegments(
ldredis.BigSegmentStore().HostAndPort("host2", 6379))
Note that the SDK also has its own options related to Big Segments that are configured at a different level, because they are independent of what database is being used. For instance, the builder returned by github.com/launchdarkly/go-server-sdk/v6/ldcomponents.BigSegments has an option for the status polling interval:
config.BigSegments = ldcomponents.BigSegments(
ldredis.BigSegmentStore().HostAndPort("host2", 6379),
).StatusPollInterval(time.Second * 30)
func DataStore() *StoreBuilder[subsystems.PersistentDataStore]
DataStore returns a configurable builder for a Redis-backed persistent data store.
This is for the main data store that holds feature flag data. To configure a data store for Big Segments, use BigSegmentStore instead.
You can use methods of the builder to specify any non-default Redis options you may want, before passing the builder to github.com/launchdarkly/go-server-sdk/v6/ldcomponents.PersistentDataStore. In this example, the store is configured to use a Redis host called "host1":
config.DataStore = ldcomponents.PersistentDataStore(
ldredis.DataStore().HostAndPort("host1", 6379))
Note that the SDK also has its own options related to data storage that are configured at a different level, because they are independent of what database is being used. For instance, the builder returned by github.com/launchdarkly/go-server-sdk/v6/ldcomponents.PersistentDataStore has options for caching:
config.DataStore = ldcomponents.PersistentDataStore(
ldredis.DataStore().HostAndPort("host1", 6379),
).CacheSeconds(15)
func (b *StoreBuilder[T]) Build(context subsystems.ClientContext) (T, error)
Build is called internally by the SDK.
func (b *StoreBuilder[T]) DescribeConfiguration() ldvalue.Value
DescribeConfiguration is used internally by the SDK to inspect the configuration.
func (b *StoreBuilder[T]) DialOptions(options ...r.DialOption) *StoreBuilder[T]
DialOptions specifies any of the advanced Redis connection options supported by Redigo, such as DialPassword.
import (
redigo "github.com/garyburd/redigo/redis"
ldredis "github.com/launchdarkly/go-server-sdk-redis-redigo/v2"
)
config.DataSource = ldcomponents.PersistentDataStore(
ldredis.DataStore().DialOptions(redigo.DialPassword("verysecure123")),
)
Note that some Redis client features can also be specified as part of the URL: see URL().
func (b *StoreBuilder[T]) HostAndPort(host string, port int) *StoreBuilder[T]
HostAndPort is a shortcut for specifying the Redis host address as a hostname and port.
func (b *StoreBuilder[T]) Pool(pool *r.Pool) *StoreBuilder[T]
Pool specifies that the data store should use a specific connection pool configuration. If not specified, it will create a default configuration (see package description). Specifying this option will cause any address specified with URL or HostAndPort to be ignored.
If you only need to change basic connection options such as providing a password, it is simpler to use DialOptions.
Use PoolInterface if you want to provide your own implementation of a connection pool.
func (b *StoreBuilder[T]) PoolInterface(pool Pool) *StoreBuilder[T]
PoolInterface is equivalent to Pool, but uses an interface type rather than a concrete implementation type. This allows implementation of custom behaviors for connection management.
func (b *StoreBuilder[T]) Prefix(prefix string) *StoreBuilder[T]
Prefix specifies a string that should be prepended to all Redis keys used by the data store. A colon will be added to this automatically. If this is unspecified or empty, DefaultPrefix will be used.
func (b *StoreBuilder[T]) URL(url string) *StoreBuilder[T]
URL specifies the Redis host URL. If not specified, the default value is DefaultURL.
Note that some Redis client features can also be specified as part of the URL: Redigo supports the redis:// syntax (https://www.iana.org/assignments/uri-schemes/prov/redis), which can include a password and a database number, as well as rediss:// (https://www.iana.org/assignments/uri-schemes/prov/rediss), which enables TLS.