SDK configuration

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

LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
    .mobileKey("example-mobile-key")
    .http(
      Components.httpConfiguration()
      .connectTimeoutMillis(5000)
    )
    .events(
      Components.sendEvents()
      .flushIntervalMillis(5000)
    )
    .build();

val ldConfig: LDConfig = LDConfig.Builder(AutoEnvAttributes.Enabled)
    .mobileKey("example-mobile-key")
    .http(
      Components.httpConfiguration()
      .connectTimeoutMillis(5000)
    )
    .events(
      Components.sendEvents()
      .flushIntervalMillis(5000)
    )
    .build();

auto config_builder = client_side::ConfigBuilder("example-mobile-key");
config_builder.Events()
    .Capacity(1000)
    .FlushInterval(std::chrono::seconds(30));
auto config = config_builder.Build();
if (!config) {
    /* an error occurred, config is not valid */
}

LDClientConfigBuilder builder = LDClientConfigBuilder_New("example-mobile-key");
LDClientConfigBuilder_Events_Capacity(builder, 1000);
LDClientConfigBuilder_Events_FlushIntervalMs(builder, 30 * 1000);
LDClientConfig config;

LDStatus status = LDClientConfigBuilder_Build(builder, &config);

if (!LDStatus_Ok(status)) {
    /* an error occurred, config is not valid */
}

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

import * as LDElectron from 'launchdarkly-electron-client-sdk'

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

final config = LDConfig(
  CredentialSource.fromEnvironment(),
  AutoEnvAttributes.enabled,
  dataSourceConfig: DataSourceConfig(
    evaluationReasons: true
  ),
);

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

LDConfig *ldConfig = [[LDConfig alloc] initWithMobileKey:@"example-mobile-key" autoEnvAttributes:AutoEnvAttributesEnabled];
ldConfig.connectionTimeout = 10.0;
ldConfig.eventFlushInterval = 30.0;

const options = { allAttributesPrivate: true };
const client = createClient('example-client-side-id', context, options);
client.start();

const result = await client.waitForInitialization({ timeout: 5 });
if (result.status === 'complete') {
// Client initialized successfully
} else if (result.status === 'failed') {
// Client failed to initialize
console.error('Initialization failed:', result.error);
} else if (result.status === 'timeout') {
// Initialization timed out
console.error('Initialization timed out');
}

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

try {
await client.waitForInitialization(5);
proceedWithSuccessfullyInitializedClient();
} catch(err) {
// Client failed to initialize or timed out
// variation() calls return fallback values until initialization completes
}

import * as LDClient from 'launchdarkly-js-client-sdk';

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

const options = {
  flushInterval: 10000, // milliseconds
  allAttributesPrivate: true
};

const client = LDClient.initialize('example-client-side-id', context, options);
try {
  await client.waitForInitialization(5);
  // initialization succeeded, flag values are now available
} catch (err) {
  // initialization failed or did not complete before timeout
}

import * as LDClient from 'launchdarkly-node-client-sdk';

const options: LDClient.LDOptions = {
  flushInterval: 10000, // milliseconds
  allAttributesPrivate: true,
};
const client = LDClient.initialize('example-client-side-id', context, options);
try {
  await client.waitForInitialization(5);
  // initialization succeeded, flag values are now available
} catch (err) {
  // initialization failed or did not complete before timeout
}

import { type LDOptions } from '@launchdarkly/react-native-client-sdk';

const options = {
  withReasons: true,
};

const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, options);

' for a legacy Roku application
config = LaunchDarklyConfig("example-mobile-key")

' for a SceneGraph Roku Application
config = LaunchDarklyConfig("example-mobile-key", CLIENT_SCENEGRAPH_NODE)

import { createApp } from 'vue'
import { LDVuePlugin } from '@launchdarkly/vue-client-sdk'
import App from './App.vue'

createApp(App)
  .use(LDVuePlugin, {
    clientSideID: 'example-client-side-id',
    context: { kind: 'user', key: 'example-context-key' },
    // Options that control the Vue integration are top-level:
    startOptions: { timeout: 5 },
    // Options for the underlying JavaScript SDK go in `ldOptions`:
    ldOptions: {
      allAttributesPrivate: true,
      streaming: true
    }
  })
  .mount('#app')

import { createLDProvider } from '@launchdarkly/vue-client-sdk'

export const LDProvider = createLDProvider(
  'example-client-side-id',
  { kind: 'user', key: 'example-context-key' },
  {
    startOptions: { timeout: 5 },
    ldOptions: {
      allAttributesPrivate: true,
      streaming: true
    }
  }
)

var config = Configuration.Builder("YOUR_SDK_KEY")
    .Events(
        Components.SendEvents().FlushInterval(TimeSpan.FromSeconds(2))
    )
    .StartWaitTime(TimeSpan.FromSeconds(5))
    .Build();
var client = new LdClient(config);

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

auto config_builder = server_side::ConfigBuilder("YOUR_SDK_KEY");
config_builder.Events()
    .Capacity(1000)
    .FlushInterval(std::chrono::seconds(30));
auto config = config_builder.Build();
if (!config) {
    /* an error occurred, config is not valid */
}

LDServerConfigBuilder builder = LDServerConfigBuilder_New("YOUR_SDK_KEY");
LDServerConfigBuilder_Events_Capacity(builder, 1000);
LDServerConfigBuilder_Events_FlushIntervalMs(builder, 30 * 1000);
LDServerConfig config;

LDStatus status = LDServerConfigBuilder_Build(builder, &config);

if (!LDStatus_Ok(status)) {
    /* an error occurred, config is not valid */
}

% Specify options
ldclient:start_instance("YOUR_SDK_KEY", #{stream => false})

% With a custom instance name
ldclient:start_instance("YOUR_SDK_KEY", your_instance, #{stream => false})

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("YOUR_SDK_KEY", config, 5*time.Second)

{-# LANGUAGE OverloadedStrings #-}

import LaunchDarkly.Server.Config

import Data.Function ((&))

config :: Config
config = (makeConfig "YOUR_SDK_KEY")
    & configSetEventsCapacity 1000
    & configSetFlushIntervalSeconds 30

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("YOUR_SDK_KEY", config);

local config = {
    events = {
        capacity = 1000,
        flushIntervalMilliseconds  = 30000
    }
}

-- This blocks for 1 second to initialize
local client = ld.clientInit("YOUR_SDK_KEY", 1000, config)

import * as ld from '@launchdarkly/node-server-sdk';

const options: ld.LDOptions = {
  timeout: 3,
};
const client = ld.init('YOUR_SDK_KEY', options);

$client = new LaunchDarkly\LDClient("YOUR_SDK_KEY", ["cache" => $cacheStorage, "connect_timeout" => 3]);

config = Config(sdk_key='YOUR_SDK_KEY', http=HTTPConfig(connect_timeout=5))
ldclient.set_config(config)

config = LaunchDarkly::Config.new({connect_timeout: 1, read_timeout: 2})
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

let config = ConfigBuilder::new("YOUR_SDK_KEY")
  .offline(true)
  .build()
  .unwrap();
let client = Client::build(config).unwrap();

import { init, LDOptions, BasicLogger } from '@launchdarkly/akamai-server-edgekv-sdk';

const options: LDOptions = {
  logger: BasicLogger.get(),
  cacheTtlMs: 200,
};

const ldClient = init({
  sdkKey: 'example-client-side-id',
  namespace: 'your-edgekv-namespace',
  group: 'your-edgekv-group-id',
  options: options,
});

// If you are using your own feature store,
// make sure to import 'init' from the 'akamai-server-base-sdk'
// rather than from 'akamai-server-edgekv-sdk'

import { init, EdgeProvider, LDOptions, BasicLogger } from '@launchdarkly/akamai-server-base-sdk';

// When using your own feature store, you must create a new class that
// implements EdgeProvider. To learn more, read
// https://launchdarkly.com/docs/sdk/edge/akamai#getting-started
class FeatureStore implements EdgeProvider {
  async get(rootKey: string): Promise<string> {
    return flagData;
  }
}

const options: LDOptions = {
  logger: BasicLogger.get(),
  cacheTtlMs: 200,
};

const ldClient = init({
  sdkKey: 'example-client-side-id',
  featureStoreProvider: new FeatureStore(),
  options: options,
});

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('example-client-side-id', env.LD_KV, options);

import { BasicLogger, init, LDOptions } from '@launchdarkly/cloudflare-server-sdk';

const options: LDOptions = {
  logger: new BasicLogger({ destination: console.log }),
};

client = init('example-client-side-id', env.LD_KV, options);

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('example-client-side-id', edgeConfigClient, options);

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 }),
};

client = init('example-client-side-id', edgeConfigClient, options);