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:

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

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

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

LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
    .mobileKey("mobile-key-123abc")
    .setConnectionTimeoutMillis(5000)
    .setEventsFlushIntervalMillis(5000)
    .build();
COPY

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

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

auto config = client_side::ConfigBuilder("mobile-key-123abc").Events()
    .Capacity(1000)
    .FlushInterval(std::chrono::seconds(30))
    .Build();
COPY

To learn more about the configuration options that are 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:

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

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

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

LDConfig ldConfig = LDConfigBuilder('mobile-key-123abc', AutoEnvAttributes.Enabled)
    .connectionTimeoutMillis(5000)
    .eventsFlushIntervalMillis(5000)
    .build();
COPY

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

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

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

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

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

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

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

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

const options = {
  flushInterval: 10000, // milliseconds
  allAttributesPrivate: true
};
const client = LDClient.initialize('client-side-id-123abc', context, options);
COPY

For a full guide to the available configuration options, read LDOptions in the TypeScript reference.

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

The config object can include a variety of options. mobileKey is a required property, but all other properties are optional.

Here is an example, in TypeScript:

import LDClient, { LDConfig } from 'launchdarkly-react-native-client-sdk';
let config: LDConfig = {
  mobileKey: 'mobile-key-123abc',
  enableAutoEnvAttributes: true,
  connectionTimeout: 3000
};
await client.configure(config, context);
COPY

Here is an example, in JavaScript:

let config = {
  mobileKey: 'mobile-key-123abc',
  enableAutoEnvAttributes: true,
  connectionTimeout: 3000
  };
await client.configure(config, context);
COPY

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

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

REM for a legacy Roku application
config = LaunchDarklyConfig("mobile-key-123abc")
REM for a SceneGraph Roku Application
config = LaunchDarklyConfig("mobile-key-123abc", CLIENT_SCENEGRAPH_NODE)
COPY

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

config.setAppURI(String)
config.setEventsURI(String)
config.setStreamURI(String)
config.setPollingIntervalSeconds(Integer)
config.setOffline(Boolean)
config.addPrivateAttribute(String)
config.setAllAttributesPrivate(Boolean)
config.setEventsCapacity(Integer)
config.setEventsFlushIntervalSeconds(Integer)
config.setLogger(Object)
config.setLoggerNode(Dynamic)
config.setStoreBackend(Object)
config.setStoreBackendNode(Dynamic)
config.setStreaming(Boolean)
config.setLogLevel(Integer)
config.setUseEvaluationReasons(Boolean)
config.setApplicationInfoValue(String, String)
COPY

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

var config = Configuration.Builder("sdk-key-123abc")
    .Events(
        Components.SendEvents().FlushInterval(TimeSpan.FromSeconds(2))
    )
    .Build();
var client = new LdClient(config);
COPY

For a complete list of configuration options for the client, including proxy settings, timeouts, and streaming/polling options, read the SDK's API documentation for ConfigurationBuilder.

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

LDConfig config = new LDConfig.Builder()
    .setAllAttributesPrivate(true)
    .build();
COPY

To learn more about the configuration options available for this SDK, read the SDK's API docs.

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

struct LDConfig *config = LDConfigNew("sdk-key-123abc");
LDConfigSetEventsCapacity(config, 1000);
LDConfigSetEventsFlushInterval(config, 30000);
COPY

For a complete list of configuration options, read the SDK's API docs.

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:

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

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:

import (
    "time"
    ld "github.com/launchdarkly/go-server-sdk/v6"
    "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
)
var config ld.Config
config.Events = ldcomponents.SendEvents().FlushInterval(10*time.Second)
client, _ := ld.MakeCustomClient("sdk-key-123abc", config, 5*time.Second)
COPY

To learn more about the configuration options, 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:

{-# LANGUAGE OverloadedStrings #-}
import LaunchDarkly.Server.Config
import Data.Function ((&))
config :: Config
config = (makeConfig "sdk-key-123abc")
    & configSetEventsCapacity 1000
    & configSetFlushIntervalSeconds 30
COPY

To learn more about the specific configuration properties that are 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.

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:

LDConfig config = new LDConfig.Builder()
  .http(
    Components.httpConfiguration()
      .connectTimeout(Duration.ofSeconds(3))
      .socketTimeout(Duration.ofSeconds(3))
  )
  .events(
    Components.sendEvents()
      .flushInterval(Duration.ofSeconds(10))
  )
  .build();
LDClient client = new LDClient("sdk-key-123abc", config);
COPY

For a complete list of configuration options for the client, including proxy settings, timeouts, and streaming/polling options, read the Javadoc for 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:

local config = {
    key                 = sdk-key-123abc,
    eventsCapacity      = 1000,
    eventsFlushInterval = 30000
}
local client = ld.clientInit(config, 1000)
COPY

To learn more about configuration options, 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:

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

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

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:

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

For a complete list of customizable parameters, read the documentation for the LDClient constructor.

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

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

The Config type lets you specify a variety of options. To learn more about the specific configuration options that are available in this SDK, read the SDK's API docs.

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:

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

To learn more about the specific configuration options that are 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:

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

The Config type lets you specify a variety of options. To learn more about the specific configuration options that are 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. The Akamai SDK only supports the logger configuration option.

import { init, LDOptions, BasicLogger } from '@launchdarkly/akamai-server-edgekv-sdk';
const options: LDOptions = {
  logger: BasicLogger.get(),
};
const ldClient = init({
  sdkKey: 'client-side-id-123abc',
  namespace: 'your-edgekv-namespace',
  group: 'your-edgekv-group-id',
  options: options,
});
COPY

To learn more about the specific configuration options that are 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.

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

To learn more about the specific configuration options that are 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.

import { createClient } from '@vercel/edge-config';
import { BasicLogger, init, LDOptions } from '@launchdarkly/vercel-server-sdk';
const edgeConfigClient = createClient(process.env.EDGE_CONFIG);
const options: LDOptions = {
  logger: new BasicLogger({ destination: console.log }),
  sendEvents: true, // default is false
};
client = init('client-side-id-123abc', edgeConfigClient, options);
COPY

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