README

LaunchDarkly Server-side SDK for Go

Circle CI Documentation

LaunchDarkly overview

LaunchDarkly is a feature management platform that serves over 100 billion feature flags daily to help teams build better software, faster. Get started using LaunchDarkly today!

Supported Go versions

This version of the LaunchDarkly SDK has been tested with Go 1.14 and higher.

Getting started

Refer to the SDK documentation for instructions on getting started with using the SDK.

Note that the base import path is gopkg.in/launchdarkly/go-server-sdk.v5, not github.com/launchdarkly/go-server-sdk. This ensures that the package can be referenced not only as a Go module, but also by projects that use older tools like dep and govendor, because the 5.x release of the Go SDK supports either module or non-module usage. Future releases of this package, and of the Go SDK, may drop support for non-module usage.

HTTPS proxy

There are two ways to specify the use of a proxy server. First, you can do it programmatically: see ldcomponents.HTTPConfiguration().

Second, Go's standard HTTP library also provides built-in support for the use of an HTTPS proxy via the HTTPS_PROXY environment variable. If this environment variable is present, then the SDK will proxy all network requests through the URL provided.

How to set the HTTPS_PROXY environment variable on Mac/Linux systems:

export HTTPS_PROXY=https://web-proxy.domain.com:8080

How to set the HTTPS_PROXY environment variable on Windows systems:

set HTTPS_PROXY=https://web-proxy.domain.com:8080

If your proxy requires authentication then you can prefix the URN with your login information:

export HTTPS_PROXY=http://user:pass@web-proxy.domain.com:8080

or

set HTTPS_PROXY=http://user:pass@web-proxy.domain.com:8080

Database integrations

Feature flag data can be kept in a persistent store using a database integration; LaunchDarkly provides integrations for several databases, such as Redis, which are provided in separate packages. See the SDK reference guide for more information.

Learn more

Check out our documentation for in-depth instructions on configuring and using LaunchDarkly. You can also head straight to the complete reference guide for this SDK or our code-generated API documentation.

Testing

We run integration tests for all our SDKs using a centralized test harness. This approach gives us the ability to test for consistency across SDKs, as well as test networking behavior in a long-running application. These tests cover each method in the SDK, and verify that event sending, flag evaluation, stream reconnection, and other aspects of the SDK all behave correctly.

Contributing

We encourage pull requests and other contributions from the community. Check out our contributing guidelines for instructions on how to contribute to this SDK.

About LaunchDarkly

  • LaunchDarkly is a continuous delivery platform that provides feature flags as a service and allows developers to iterate quickly and safely. We allow you to easily flag your features and manage them from the LaunchDarkly dashboard. With LaunchDarkly, you can:
    • Roll out a new feature to a subset of your users (like a group of users who opt-in to a beta tester group), gathering feedback and bug reports from real-world use cases.
    • Gradually roll out a feature to an increasing percentage of users, and track the effect that the feature has on key metrics (for instance, how likely is a user to complete a purchase if they have feature A versus feature B?).
    • Turn off a feature that you realize is causing performance problems in production, without needing to re-deploy, or even restart the application with a changed configuration file.
    • Grant access to certain features based on user attributes, like payment plan (eg: users on the ‘gold’ plan get access to more features than users in the ‘silver’ plan). Disable parts of your application to facilitate maintenance, without taking everything offline.
  • LaunchDarkly provides feature flag SDKs for a wide variety of languages and technologies. Check out our documentation for a complete list.
  • Explore LaunchDarkly
Expand ▾ Collapse ▴

Documentation

Overview

Package ldclient is the main package for the LaunchDarkly SDK.

This package contains the types and methods for the SDK client (LDClient) and its overall configuration.

Subpackages in the same repository provide additional functionality for specific features of the client. Most applications that need to change any configuration settings will use the ldcomponents package (https://pkg.go.dev/gopkg.in/launchdarkly/go-server-sdk.v5/ldcomponents).

The SDK also uses types from the go-sdk-common.v2 repository and its subpackages (https://pkg.go.dev/gopkg.in/launchdarkly/go-sdk-common.v2) that represent standard data structures in the LaunchDarkly model. All applications that evaluate feature flags will use the lduser package (https://pkg.go.dev/gopkg.in/launchdarkly/go-sdk-common.v2/lduser); for some features such as custom attributes, the ldvalue package is also helpful.

For more information and code examples, see the Go SDK Reference: https://docs.launchdarkly.com/sdk/server-side/go

Index

Constants

const Version = internal.SDKVersion

Version is the SDK version.


Variables

var (
	// MakeClient and MakeCustomClient will return this error if the SDK was not able to establish a
	// LaunchDarkly connection within the specified time interval. In this case, the LDClient will still
	// continue trying to connect in the background.
	ErrInitializationTimeout = errors.New("timeout encountered waiting for LaunchDarkly client initialization")

	// MakeClient and MakeCustomClient will return this error if the SDK detected an error that makes it
	// impossible for a LaunchDarkly connection to succeed. Currently, the only such condition is if the
	// SDK key is invalid, since an invalid SDK key will never become valid.
	ErrInitializationFailed = errors.New("LaunchDarkly client initialization failed")

	// This error is returned by the Variation/VariationDetail methods if feature flags are not available
	// because the client has not successfully initialized. In this case, the result value will be whatever
	// default value was specified by the application.
	ErrClientNotInitialized = errors.New("feature flag evaluation called before LaunchDarkly client initialization completed") //nolint:lll
)

Initialization errors


Functions

This section is empty.

Types

type Config

type Config struct {
	// Sets the implementation of DataSource for receiving feature flag updates.
	//
	// If nil, the default is ldcomponents.StreamingDataSource(); see that method for an explanation of how to
	// further configure streaming behavior. Other options include ldcomponents.PollingDataSource(),
	// ldcomponents.ExternalUpdatesOnly(), ldfiledata.DataSource(), or a custom implementation for testing.
	//
	// If Offline is set to true, then DataSource is ignored.
	//
	//     // example: using streaming mode and setting streaming options
	//     config.DataSource = ldcomponents.StreamingDataSource().InitialReconnectDelay(time.Second)
	//
	//     // example: using polling mode and setting polling options
	//     config.DataSource = ldcomponents.PollingDataSource().PollInterval(time.Minute)
	//
	//     // example: specifying that data will be updated by an external process (such as the Relay Proxy)
	//     config.DataSource = ldcomponents.ExternalUpdatesOnly()
	DataSource interfaces.DataSourceFactory

	// Sets the implementation of DataStore for holding feature flags and related data received from
	// LaunchDarkly.
	//
	// If nil, the default is ldcomponents.InMemoryDataStore().
	//
	// The other option is to use a persistent data store-- that is, a database integration. These all use
	// ldcomponents.PersistentDataStore(), plus an adapter for the specific database. LaunchDarkly provides
	// adapters for several databases, as described in the Reference Guide:
	// https://docs.launchdarkly.com/sdk/concepts/feature-store
	//
	// You could also define your own database integration by implementing the PersistentDataStore interface.
	//
	//     // example: use Redis, with default properties
	//     import ldredis "github.com/launchdarkly/go-server-sdk-redis-redigo"
	//
	//     config.DataStore = ldcomponents.PersistentDataStore(ldredis.DataStore())
	DataStore interfaces.DataStoreFactory

	// Set to true to opt out of sending diagnostic events.
	//
	// Unless DiagnosticOptOut is set to true, the client will send some diagnostics data to the LaunchDarkly
	// servers in order to assist in the development of future SDK improvements. These diagnostics consist of an
	// initial payload containing some details of the SDK in use, the SDK's configuration, and the platform the
	// SDK is being run on, as well as payloads sent periodically with information on irregular occurrences such
	// as dropped events.
	DiagnosticOptOut bool

	// Sets the SDK's behavior regarding analytics events.
	//
	// If nil, the default is ldcomponents.SendEvents(); see that method for an explanation of how to further
	// configure event delivery. You may also turn off event delivery using ldcomponents.NoEvents().
	//
	// If Offline is set to true, then event delivery is always off and Events is ignored.
	//
	//     // example: enable events, flush the events every 10 seconds, buffering up to 5000 events
	//     config.Events = ldcomponents.SendEvents().FlushInterval(10 * time.Second).Capacity(5000)
	Events interfaces.EventProcessorFactory

	// Provides configuration of the SDK's network connection behavior.
	//
	// If nil, the default is ldcomponents.HTTPConfiguration(); see that method for an explanation of how to
	// further configure these options.
	//
	// If Offline is set to true, then HTTP is ignored.
	//
	//     // example: set connection timeout to 8 seconds and use a proxy server
	//     config.HTTP = ldcomponents.HTTPConfiguration().ConnectTimeout(8 * time.Second).ProxyURL(myProxyURL)
	HTTP interfaces.HTTPConfigurationFactory

	// Provides configuration of the SDK's logging behavior.
	//
	// If nil, the default is ldcomponents.Logging(); see that method for an explanation of how to
	// further configure logging behavior. The other option is ldcomponents.NoLogging().
	//
	// This example sets the minimum logging level to Warn, so Debug and Info messages will not be logged:
	//
	//     // example: enable logging only for Warn level and above
	//     // (note: ldlog is gopkg.in/launchdarkly/go-sdk-common.v2/ldlog)
	//     config.Logging = ldcomponents.Logging().MinLevel(ldlog.Warn)
	Logging interfaces.LoggingConfigurationFactory

	// Sets whether this client is offline. An offline client will not make any network connections to LaunchDarkly,
	// and will return default values for all feature flags.
	//
	// For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#offline-mode
	Offline bool
}

Config exposes advanced configuration options for the LaunchDarkly client.

All of these settings are optional, so an empty Config struct is always valid. See the description of each field for the default behavior if it is not set.

Some of the Config fields are actually factories for subcomponents of the SDK. The types of these fields are interfaces whose names end in "Factory"; the actual implementation types, which have methods for configuring that subcomponent, are normally provided by corresponding functions in the ldcomponents package (https://pkg.go.dev/gopkg.in/launchdarkly/go-server-sdk.v5/ldcomponents). For instance, to set the Events field to a configuration in which the SDK will flush analytics events every 10 seconds:

var config ld.Config
config.Events = ldcomponents.Events().FlushInterval(time.Second * 10)

The interfaces are defined separately from the built-in component implementations because you could also define your own implementation, for custom SDK integrations.

type LDClient

type LDClient struct {
	// contains filtered or unexported fields
}

LDClient is the LaunchDarkly client.

This object evaluates feature flags, generates analytics events, and communicates with LaunchDarkly services. Applications should instantiate a single instance for the lifetime of their application and share it wherever feature flags need to be evaluated; all LDClient methods are safe to be called concurrently from multiple goroutines.

Some advanced client features are grouped together in API facades that are accessed through an LDClient method, such as GetDataSourceStatusProvider().

When an application is shutting down or no longer needs to use the LDClient instance, it should call Close() to ensure that all of its connections and goroutines are shut down and that any pending analytics events have been delivered.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go

func MakeClient

func MakeClient(sdkKey string, waitFor time.Duration) (*LDClient, error)

MakeClient creates a new client instance that connects to LaunchDarkly with the default configuration.

For advanced configuration options, use MakeCustomClient. Calling MakeClient is exactly equivalent to calling MakeCustomClient with the config parameter set to an empty value, ld.Config{}.

Unless it is configured to be offline with Config.Offline or ldcomponents.ExternalUpdatesOnly(), the client will begin attempting to connect to LaunchDarkly as soon as you call this constructor. The constructor will return when it successfully connects, or when the timeout set by the waitFor parameter expires, whichever comes first.

If the connection succeeded, the first return value is the client instance, and the error value is nil.

If the timeout elapsed without a successful connection, it still returns a client instance-- in an uninitialized state, where feature flags will return default values-- and the error value is ErrInitializationTimeout. In this case, it will still continue trying to connect in the background.

If there was an unrecoverable error such that it cannot succeed by retrying-- for instance, the SDK key is invalid-- it will return a client instance in an uninitialized state, and the error value is ErrInitializationFailed.

If you set waitFor to zero, the function will return immediately after creating the client instance, and do any further initialization in the background.

The only time it returns nil instead of a client instance is if the client cannot be created at all due to an invalid configuration. This is rare, but could happen if for instance you specified a custom TLS certificate file that did not contain a valid certificate.

For more about the difference between an initialized and uninitialized client, and other ways to monitor the client's status, see LDClient.Initialized() and LDClient.GetDataSourceStatusProvider().

func MakeCustomClient

func MakeCustomClient(sdkKey string, config Config, waitFor time.Duration) (*LDClient, error)

MakeCustomClient creates a new client instance that connects to LaunchDarkly with a custom configuration.

The config parameter allows customization of all SDK properties; some of these are represented directly as fields in Config, while others are set by builder methods on a more specific configuration object. See Config for details.

Unless it is configured to be offline with Config.Offline or ldcomponents.ExternalUpdatesOnly(), the client will begin attempting to connect to LaunchDarkly as soon as you call this constructor. The constructor will return when it successfully connects, or when the timeout set by the waitFor parameter expires, whichever comes first.

If the connection succeeded, the first return value is the client instance, and the error value is nil.

If the timeout elapsed without a successful connection, it still returns a client instance-- in an uninitialized state, where feature flags will return default values-- and the error value is ErrInitializationTimeout. In this case, it will still continue trying to connect in the background.

If there was an unrecoverable error such that it cannot succeed by retrying-- for instance, the SDK key is invalid-- it will return a client instance in an uninitialized state, and the error value is ErrInitializationFailed.

If you set waitFor to zero, the function will return immediately after creating the client instance, and do any further initialization in the background.

The only time it returns nil instead of a client instance is if the client cannot be created at all due to an invalid configuration. This is rare, but could happen if for instance you specified a custom TLS certificate file that did not contain a valid certificate.

For more about the difference between an initialized and uninitialized client, and other ways to monitor the client's status, see LDClient.Initialized() and LDClient.GetDataSourceStatusProvider().

func (*LDClient) AllFlagsState

func (client *LDClient) AllFlagsState(user lduser.User, options ...flagstate.Option) flagstate.AllFlags

AllFlagsState returns an object that encapsulates the state of all feature flags for a given user. This includes the flag values, and also metadata that can be used on the front end.

The most common use case for this method is to bootstrap a set of client-side feature flags from a back-end service.

You may pass any combination of flagstate.ClientSideOnly, flagstate.WithReasons, and flagstate.DetailsOnlyForTrackedFlags as optional parameters to control what data is included.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#all-flags

func (*LDClient) BoolVariation

func (client *LDClient) BoolVariation(key string, user lduser.User, defaultVal bool) (bool, error)

BoolVariation returns the value of a boolean feature flag for a given user.

Returns defaultVal if there is an error, if the flag doesn't exist, or the feature is turned off and has no off variation.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variation

func (*LDClient) BoolVariationDetail

func (client *LDClient) BoolVariationDetail(
	key string,
	user lduser.User,
	defaultVal bool,
) (bool, ldreason.EvaluationDetail, error)

BoolVariationDetail is the same as BoolVariation, but also returns further information about how the value was calculated. The "reason" data will also be included in analytics events.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variationdetail

func (*LDClient) Close

func (client *LDClient) Close() error

Close shuts down the LaunchDarkly client. After calling this, the LaunchDarkly client should no longer be used. The method will block until all pending analytics events (if any) been sent.

func (*LDClient) Float64Variation

func (client *LDClient) Float64Variation(key string, user lduser.User, defaultVal float64) (float64, error)

Float64Variation returns the value of a feature flag (whose variations are floats) for the given user.

Returns defaultVal if there is an error, if the flag doesn't exist, or the feature is turned off and has no off variation.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variation

func (*LDClient) Float64VariationDetail

func (client *LDClient) Float64VariationDetail(
	key string,
	user lduser.User,
	defaultVal float64,
) (float64, ldreason.EvaluationDetail, error)

Float64VariationDetail is the same as Float64Variation, but also returns further information about how the value was calculated. The "reason" data will also be included in analytics events.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variationdetail

func (*LDClient) Flush

func (client *LDClient) Flush()

Flush tells the client that all pending analytics events (if any) should be delivered as soon as possible. Flushing is asynchronous, so this method will return before it is complete. However, if you call Close(), events are guaranteed to be sent before that method returns.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#flush

func (*LDClient) GetDataSourceStatusProvider

func (client *LDClient) GetDataSourceStatusProvider() interfaces.DataSourceStatusProvider

GetDataSourceStatusProvider returns an interface for tracking the status of the data source.

The data source is the mechanism that the SDK uses to get feature flag configurations, such as a streaming connection (the default) or poll requests. The DataSourceStatusProvider has methods for checking whether the data source is (as far as the SDK knows) currently operational and tracking changes in this status.

See the DataSourceStatusProvider interface for more about this functionality.

func (*LDClient) GetDataStoreStatusProvider

func (client *LDClient) GetDataStoreStatusProvider() interfaces.DataStoreStatusProvider

GetDataStoreStatusProvider returns an interface for tracking the status of a persistent data store.

The DataStoreStatusProvider has methods for checking whether the data store is (as far as the SDK SDK knows) currently operational, tracking changes in this status, and getting cache statistics. These are only relevant for a persistent data store; if you are using an in-memory data store, then this method will always report that the store is operational.

See the DataStoreStatusProvider interface for more about this functionality.

func (*LDClient) GetFlagTracker

func (client *LDClient) GetFlagTracker() interfaces.FlagTracker

GetFlagTracker returns an interface for tracking changes in feature flag configurations.

See the FlagTracker interface for more about this functionality.

func (*LDClient) Identify

func (client *LDClient) Identify(user lduser.User) error

Identify reports details about a user.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#identify

func (*LDClient) Initialized

func (client *LDClient) Initialized() bool

Initialized returns whether the LaunchDarkly client is initialized.

If this value is true, it means the client has succeeded at some point in connecting to LaunchDarkly and has received feature flag data. It could still have encountered a connection problem after that point, so this does not guarantee that the flags are up to date; if you need to know its status in more detail, use GetDataSourceStatusProvider.

If this value is false, it means the client has not yet connected to LaunchDarkly, or has permanently failed. See MakeClient for the reasons that this could happen. In this state, feature flag evaluations will always return default values-- unless you are using a database integration and feature flags had already been stored in the database by a successfully connected SDK in the past. You can use GetDataSourceStatusProvider to get information on errors, or to wait for a successful retry.

func (*LDClient) IntVariation

func (client *LDClient) IntVariation(key string, user lduser.User, defaultVal int) (int, error)

IntVariation returns the value of a feature flag (whose variations are integers) for the given user.

Returns defaultVal if there is an error, if the flag doesn't exist, or the feature is turned off and has no off variation.

If the flag variation has a numeric value that is not an integer, it is rounded toward zero (truncated).

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variation

func (*LDClient) IntVariationDetail

func (client *LDClient) IntVariationDetail(
	key string,
	user lduser.User,
	defaultVal int,
) (int, ldreason.EvaluationDetail, error)

IntVariationDetail is the same as IntVariation, but also returns further information about how the value was calculated. The "reason" data will also be included in analytics events.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variationdetail

func (*LDClient) IsOffline

func (client *LDClient) IsOffline() bool

IsOffline returns whether the LaunchDarkly client is in offline mode.

This is only true if you explicitly set the Config.Offline property to true, to force the client to be offline. It does not mean that the client is having a problem connecting to LaunchDarkly. To detect the status of a client that is configured to be online, use Initialized() or GetDataSourceStatusProvider().

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#offline-mode

func (*LDClient) JSONVariation

func (client *LDClient) JSONVariation(key string, user lduser.User, defaultVal ldvalue.Value) (ldvalue.Value, error)

JSONVariation returns the value of a feature flag for the given user, allowing the value to be of any JSON type.

The value is returned as an ldvalue.Value, which can be inspected or converted to other types using Value methods such as GetType() and BoolValue(). The defaultVal parameter also uses this type. For instance, if the values for this flag are JSON arrays:

defaultValAsArray := ldvalue.BuildArray().
    Add(ldvalue.String("defaultFirstItem")).
    Add(ldvalue.String("defaultSecondItem")).
    Build()
result, err := client.JSONVariation(flagKey, user, defaultValAsArray)
firstItemAsString := result.GetByIndex(0).StringValue() // "defaultFirstItem", etc.

You can also use unparsed json.RawMessage values:

defaultValAsRawJSON := ldvalue.Raw(json.RawMessage(`{"things":[1,2,3]}`))
result, err := client.JSONVariation(flagKey, user, defaultValAsJSON
resultAsRawJSON := result.AsRaw()

Returns defaultVal if there is an error, if the flag doesn't exist, or the feature is turned off.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variation

func (*LDClient) JSONVariationDetail

func (client *LDClient) JSONVariationDetail(
	key string,
	user lduser.User,
	defaultVal ldvalue.Value,
) (ldvalue.Value, ldreason.EvaluationDetail, error)

JSONVariationDetail is the same as JSONVariation, but also returns further information about how the value was calculated. The "reason" data will also be included in analytics events.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variationdetail

func (*LDClient) SecureModeHash

func (client *LDClient) SecureModeHash(user lduser.User) string

SecureModeHash generates the secure mode hash value for a user.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#secure-mode-hash

func (*LDClient) StringVariation

func (client *LDClient) StringVariation(key string, user lduser.User, defaultVal string) (string, error)

StringVariation returns the value of a feature flag (whose variations are strings) for the given user.

Returns defaultVal if there is an error, if the flag doesn't exist, or the feature is turned off and has no off variation.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variation

func (*LDClient) StringVariationDetail

func (client *LDClient) StringVariationDetail(
	key string,
	user lduser.User,
	defaultVal string,
) (string, ldreason.EvaluationDetail, error)

StringVariationDetail is the same as StringVariation, but also returns further information about how the value was calculated. The "reason" data will also be included in analytics events.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#variationdetail

func (*LDClient) TrackData

func (client *LDClient) TrackData(eventName string, user lduser.User, data ldvalue.Value) error

TrackData reports that a user has performed an event, and associates it with custom data.

The eventName parameter is defined by the application and will be shown in analytics reports; it normally corresponds to the event name of a metric that you have created through the LaunchDarkly dashboard.

The data parameter is a value of any JSON type, represented with the ldvalue.Value type, that will be sent with the event. If no such value is needed, use ldvalue.Null() (or call TrackEvent instead). To send a numeric value for experimentation, use TrackMetric.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#track

func (*LDClient) TrackEvent

func (client *LDClient) TrackEvent(eventName string, user lduser.User) error

TrackEvent reports that a user has performed an event.

The eventName parameter is defined by the application and will be shown in analytics reports; it normally corresponds to the event name of a metric that you have created through the LaunchDarkly dashboard. If you want to associate additional data with this event, use TrackData or TrackMetric.

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#track

func (*LDClient) TrackMetric

func (client *LDClient) TrackMetric(eventName string, user lduser.User, metricValue float64, data ldvalue.Value) error

TrackMetric reports that a user has performed an event, and associates it with a numeric value. This value is used by the LaunchDarkly experimentation feature in numeric custom metrics, and will also be returned as part of the custom event for Data Export.

The eventName parameter is defined by the application and will be shown in analytics reports; it normally corresponds to the event name of a metric that you have created through the LaunchDarkly dashboard.

The data parameter is a value of any JSON type, represented with the ldvalue.Value type, that will be sent with the event. If no such value is needed, use ldvalue.Null().

For more information, see the Reference Guide: https://docs.launchdarkly.com/sdk/server-side/go#track

func (*LDClient) WithEventsDisabled

func (client *LDClient) WithEventsDisabled(disabled bool) interfaces.LDClientInterface

WithEventsDisabled returns a decorator for the LDClient that implements the same basic operations but will not generate any analytics events.

If events were already disabled, this is just the same LDClient. Otherwise, it is an object whose Variation methods use the same LDClient to evaluate feature flags, but without generating any events, and whose Identify/Track/Custom methods do nothing. Neither evaluation counts nor user properties will be sent to LaunchDarkly for any operations done with this object.

You can use this to suppress events within some particular area of your code where you do not want evaluations to affect your dashboard statistics, or do not want to incur the overhead of processing the events.

Note that if the original client configuration already had events disabled (config.Events = ldcomponents.NoEvents()), you cannot re-enable them with this method. It is only useful for temporarily disabling events on a client that had them enabled.

Directories

Path Synopsis
interfaces Package interfaces contains interfaces that allow customization of LaunchDarkly components, and interfaces to other advanced SDK features.
interfaces/flagstate Package flagstate contains the data types used by the LDClient.AllFlagsState() method.
interfaces/ldstoretypes Package ldstoretypes contains types that are only needed when implementing custom components.
internal Package internal contains SDK implementation details that are shared between packages, but are not exposed to application code.
internal/datakinds Package datakinds contains the implementations of ldstoretypes.DataKind for flags and segments.
internal/datasource Package datasource is an internal package containing implementation types for the SDK's data source implementations (streaming, polling, etc.) and related functionality.
internal/datastore Package datastore is an internal package containing implementation types for the SDK's data store implementations (in-memory vs.
internal/sharedtest nolint:gochecknoglobals,golint,stylecheck Package sharedtest contains types and functions used by SDK unit tests in multiple packages.
ldcomponents Package ldcomponents provides the standard implementations and configuration options of LaunchDarkly components.
ldcomponents/ldstoreimpl Package ldstoreimpl contains SDK data store implementation objects that may be used by external code such as custom data store integrations and internal LaunchDarkly components.
ldfiledata Package ldfiledata allows the LaunchDarkly client to read feature flag data from a file.
ldfilewatch Package ldfilewatch allows the LaunchDarkly client to read feature flag data from a file that will be automatically reloaded if the file changes.
ldhttp Package ldhttp provides internal helper functions for custom HTTP configuration.
ldntlm Package ldntlm allows you to configure the SDK to connect to LaunchDarkly through a proxy server that uses NTLM authentication.
testhelpers Package testhelpers contains types and functions that may be useful in testing SDK functionality or custom integrations.
testhelpers/ldtestdata Package ldtestdata provides a mechanism for providing dynamically updatable feature flag state in a simplified form to an SDK client in test scenarios.
testhelpers/storetest Package storetest contains the standard test suite for persistent data store implementations.