Configuration

This code sample shows you how to create a custom configuration object to pass custom parameters to the client. With it, we’ve configured the event queue flush frequency.

You can configure Configuration.Builder:

1
var config = Configuration
2
    .Builder("mobile-key-123abc", ConfigurationBuilder.AutoEnvAttributes.Enabled)
3
    .Events(Components.SendEvents().FlushInterval(TimeSpan.FromSeconds(2)))
4
    .Build();
5
LdClient client = LdClient.Init(config, context);

To learn more about the specific configuration options available in this SDK, read Configuration.

In the Android SDK, most of the configuration properties are grouped into areas of functionality, each of which has its own builder class that is only available if you are using that functionality. The basic areas of functionality are data source, events, networking, and service URIs.

This code sample shows you how to configure the client connect and flush interval parameters:

1
LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
2
    .mobileKey("mobile-key-123abc")
3
    .http(
4
      Components.httpConfiguration()
5
      .connectTimeoutMillis(5000)
6
    )
7
    .events(
8
      Components.sendEvents()
9
      .flushIntervalMillis(5000)
10
    )
11
    .build();

To learn more about the specific configuration options available in this SDK, read LDConfig.Builder.

This code sample shows you how to configure the event queue capacity and flush interval parameters:

1
auto config_builder = client_side::ConfigBuilder("mobile-key-123abc");
2
config_builder.Events()
3
    .Capacity(1000)
4
    .FlushInterval(std::chrono::seconds(30));
5
auto config = config_builder.Build();
6
if (!config) {
7
    /* an error occurred, config is not valid */
8
}

To learn more about the specific configuration options available in this SDK, read ConfigBuilder. To learn more about the event queue capacity and flush interval parameters specifically, read EventsBuilder.

This code sample shows you how to create a custom configuration object to pass custom parameters to the client:

1
const options = {
2
  allAttributesPrivate: true
3
};
4
const client = LDElectron.initializeInMain('client-side-id-123abc', user, options);

To learn more about the specific configuration options available in this SDK, read LDOptions.

The Flutter SDK version 4 uses either a mobile key or a client-side ID, depending on the platform that you build for. You can set these in the LAUNCHDARKLY_MOBILE_KEY and LAUNCHDARKLY_CLIENT_SIDE_ID environment variables, and then use the CredentialSource helper to select your credential and provide it to your configuration. CredentialSource expects one of the two environment variables to be set, but not both.

This code sample shows you how to configure the credential, automatic environment attributes, and evaluation reasons options:

1
final config = LDConfig(
2
  CredentialSource.fromEnvironment,
3
  AutoEnvAttributes.enabled,
4
  dataSourceConfig: DataSourceConfig(
5
    evaluationReasons: true
6
  ),
7
);

The credential and automatic environment attributes configuration options are required. All other configuration options are optional and use default values if not set.

To learn more about the specific configuration options available in this SDK, read LDConfig.

This code sample shows you how to configure the client connection timeout and event flush interval parameters:

1
var ldConfig = LDConfig(mobileKey: "mobile-key-123abc", autoEnvAttributes: .enabled)
2
ldConfig.connectionTimeout = 10.0
3
ldConfig.eventFlushInterval = 30.0

To learn more about the specific configuration options available in this SDK, read LDConfig.

This code sample shows you how to create a custom configuration object to pass custom parameters to the client:

1
const options = { allAttributesPrivate: true };
2
const client = LDClient.initialize('client-side-id-123abc', context, options);

To learn more about the specific configuration options available in this SDK, read LDOptions.

This code sample shows you how to create a custom configuration object to pass custom parameters to the client:

1
const options = {
2
  flushInterval: 10000, // milliseconds
3
  allAttributesPrivate: true
4
};
5
6
const client = LDClient.initialize('client-side-id-123abc', context, options);
7
try {
8
  await client.waitForInitialization(5);
9
  // initialization succeeded, flag values are now available
10
} catch (err) {
11
  // initialization failed or did not complete before timeout
12
}

To learn more about the specific configuration options available in this SDK, read LDOptions.

This code sample shows you how to create a configuration object to pass configuration parameters to the client.

The configuration object can include a variety of options. In version 10 of the SDK, all properties are optional.

In versions 9 and earlier, mobileKey was a required property, but all other properties were optional. Additionally, in versions 9 and earlier we recommend setting a timeout parameter when you call configure. If the client receives flag values before the timeout, the returned promise will resolve. Otherwise, it will be rejected.

Here is an example:

1
import { type LDOptions } from '@launchdarkly/react-native-client-sdk';
2
3
const options = {
4
  withReasons: true,
5
};
6
7
const client = new ReactNativeLDClient('mobile-key-123abc', AutoEnvAttributes.Enabled, options);

To learn more about the specific configuration options available in this SDK, read LDOptions.

This code sample shows you how to create a configuration object:

1
' for a legacy Roku application
2
config = LaunchDarklyConfig("mobile-key-123abc")
3
4
' for a SceneGraph Roku Application
5
config = LaunchDarklyConfig("mobile-key-123abc", CLIENT_SCENEGRAPH_NODE)

We support the following configuration options for both SceneGraph and non-SceneGraph usage:

1
config.setAppURI(String)
2
3
config.setEventsURI(String)
4
5
config.setStreamURI(String)
6
7
8
config.setPollingIntervalSeconds(Integer)
9
10
config.setOffline(Boolean)
11
12
13
config.addPrivateAttribute(String)
14
15
config.setAllAttributesPrivate(Boolean)
16
17
18
config.setEventsCapacity(Integer)
19
20
config.setEventsFlushIntervalSeconds(Integer)
21
22
23
config.setLogger(Object)
24
25
config.setLoggerNode(Dynamic)
26
27
config.setStoreBackend(Object)
28
29
config.setStoreBackendNode(Dynamic)
30
31
32
config.setStreaming(Boolean)
33
34
config.setLogLevel(Integer)
35
36
37
config.setUseEvaluationReasons(Boolean)
38
39
config.setApplicationInfoValue(String, String)

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object:

1
var config = Configuration.Builder("sdk-key-123abc")
2
    .Events(
3
        Components.SendEvents().FlushInterval(TimeSpan.FromSeconds(2))
4
    )
5
    .StartWaitTime(TimeSpan.FromSeconds(5))
6
    .Build();
7
var client = new LdClient(config);

To learn more about the specific configuration that are available in this SDK, read ConfigurationBuilder.

This code sample shows you how to configure the client to redact all user attributes in events:

1
LDConfig config = new LDConfig.Builder()
2
    .setAllAttributesPrivate(true)
3
    .build();

To learn more about the specific configuration options available for this SDK, read LDConfig.Builder.

This code sample shows you how to configure the event queue capacity and flush interval parameters:

1
auto config_builder = server_side::ConfigBuilder("sdk-key-123abc");
2
config_builder.Events()
3
    .Capacity(1000)
4
    .FlushInterval(std::chrono::seconds(30));
5
auto config = config_builder.Build();
6
if (!config) {
7
    /* an error occurred, config is not valid */
8
}

To learn more about the specific configuration options available for this SDK, read ConfigBuilder. To learn more about the event queue capacity and flush interval parameters specifically, read EventsBuilder.

This code sample shows you how to pass custom parameters when the client starts with the Options map parameter. The code in this example turns off streaming, so the SDK connects to LaunchDarkly through polling.

To pass custom parameters:

1
% Specify options
2
ldclient:start_instance("sdk-key-123abc", #{stream => false})
3
4
% With a custom instance name
5
ldclient:start_instance("sdk-key-123abc", your_instance, #{stream => false})

To learn more about the specific configuration options available for this SDK, read ldclient_config.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object. The code in this sample configures the event flush interval parameter.

To pass custom parameters:

1
import (
2
    "time"
3
4
    ld "github.com/launchdarkly/go-server-sdk/v6"
5
    "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
6
)
7
8
var config ld.Config
9
10
config.Events = ldcomponents.SendEvents().FlushInterval(10*time.Second)
11
12
client, _ := ld.MakeCustomClient("sdk-key-123abc", config, 5*time.Second)

To learn more about the specific configuration options available for this SDK, read Config.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object. This example configures the event queue capacity and flush interval parameters.

To pass custom parameters:

1
{-# LANGUAGE OverloadedStrings #-}
2
3
import LaunchDarkly.Server.Config
4
5
import Data.Function ((&))
6
7
config :: Config
8
config = (makeConfig "sdk-key-123abc")
9
    & configSetEventsCapacity 1000
10
    & configSetFlushIntervalSeconds 30

To learn more about the specific configuration properties that are available in this SDK, read Config.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object.

In this example, we’ve configured two properties for HTTP (the connect and socket timeouts), and one property for analytics events (the event flush interval).

To pass custom parameters:

1
LDConfig config = new LDConfig.Builder()
2
  .http(
3
    Components.httpConfiguration()
4
      .connectTimeout(Duration.ofSeconds(3))
5
      .socketTimeout(Duration.ofSeconds(3))
6
  )
7
  .events(
8
    Components.sendEvents()
9
      .flushInterval(Duration.ofSeconds(10))
10
  )
11
  .build();
12
LDClient client = new LDClient("sdk-key-123abc", config);

To learn more about the specific configuration properties that are available in this SDK, read LDConfig.Builder.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object.

Here, we’ve configured the event queue capacity and flush interval parameters:

1
local config = {
2
    events = {
3
        capacity = 1000,
4
        flushIntervalMilliseconds  = 30000
5
    }
6
}
7
8
-- This blocks for 1 second to initialize
9
local client = ld.clientInit("sdk-key-123abc", 1000, config)

To learn more about the specific configuration properties that are available in this SDK, read clientInit.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object:

1
import * as ld from '@launchdarkly/node-server-sdk';
2
3
const options: ld.LDOptions = {
4
  timeout: 3,
5
};
6
const client = ld.init('sdk-key-123abc', options);

To learn more about the specific configuration options available in this SDK, read LDOptions.

This code sample uses the cache option, which passes as an array to the client constructor. There are a few additional options you can set in this array.

We’ve set the client connect timeout to three seconds in addition to providing a custom cache storage provider.

Here is an example:

1
$client = new LaunchDarkly\LDClient("sdk-key-123abc", ["cache" => $cacheStorage, "connect_timeout" => 3]);

To learn more about the specific configuration options available in this SDK, read the SDK API documentation for the LDClient constructor.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object:

1
config = Config(sdk_key='sdk-key-123abc', http=HTTPConfig(connect_timeout=5))
2
ldclient.set_config(config)

To learn more about the specific configuration options available in this SDK, read ldclient.config.

This code sample shows you how to configure the behavior of the client by creating a custom configuration object.

The client constructor takes a configuration object as an optional parameter. In this example, we’ve set the connection timeout to LaunchDarkly to one second, and the read timeout to two seconds.

To create a custom configuration object:

1
config = LaunchDarkly::Config.new({connect_timeout: 1, read_timeout: 2})
2
client = LaunchDarkly::LDClient.new("sdk-key-123abc", config)

To learn more about the specific configuration options available in this SDK, read Config.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object:

1
let config = ConfigBuilder::new("sdk-key-123abc")
2
  .offline(true)
3
  .build();
4
let client = Client::build(config).unwrap();

To learn more about the specific configuration options available in this SDK, read Config.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object. The Akamai SDK only supports the logger configuration option.

1
import { init, LDOptions, BasicLogger } from '@launchdarkly/akamai-server-edgekv-sdk';
2
3
const options: LDOptions = {
4
  logger: BasicLogger.get(),
5
};
6
7
const ldClient = init({
8
  sdkKey: 'client-side-id-123abc',
9
  namespace: 'your-edgekv-namespace',
10
  group: 'your-edgekv-group-id',
11
  options: options,
12
});

To learn more about the specific configuration options available in this SDK, read LDOptions.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object.

Versions 1 and 2 of the Cloudflare SDK only support the logger configuration option. Versions 2.3.0 and later also support an events configuration option.

1
import { BasicLogger, init, LDOptions } from '@launchdarkly/cloudflare-server-sdk';
2
3
const options: LDOptions = {
4
  logger: new BasicLogger({ destination: console.log }),
5
  sendEvents: true, // default is false
6
};
7
8
client = init('client-side-id-123abc', env.LD_KV, options);

To learn more about the specific configuration options available in this SDK, read the SDK’s API docs.

This code sample shows you how to pass custom parameters to the client by creating a custom configuration object.

Version 1 of the Vercel SDK only supports the logger configuration option. Versions 1.2.0 and later also support an events configuration option.

1
import { createClient } from '@vercel/edge-config';
2
import { BasicLogger, init, LDOptions } from '@launchdarkly/vercel-server-sdk';
3
4
const edgeConfigClient = createClient(process.env.EDGE_CONFIG);
5
6
const options: LDOptions = {
7
  logger: new BasicLogger({ destination: console.log }),
8
  sendEvents: true, // default is false
9
};
10
11
client = init('client-side-id-123abc', edgeConfigClient, options);

To learn more about the specific configuration options available in this SDK, read LDOptions.