Using daemon mode

1
var config = Configuration.Builder("YOUR_SDK_KEY")
2
    .DataStore(
3
        Components.PersistentDataStore(
4
            SomeDatabaseName.DataStore()
5
        )
6
    )
7
    .DataSource(Components.ExternalUpdatesOnly)
8
    .Build();

1
var config = Configuration.Builder("YOUR_SDK_KEY")
2
    .DataSystem(
3
        Components.DataSystem().Daemon(
4
            Components.PersistentDataStore(Redis.DataStore())
5
        )
6
    )
7
    .Build();

1
ldclient:start_instance("YOUR_SDK_KEY", #{
2
  use_ldd => true,
3
  feature_store => your_feature_store
4
})

1
config := ld.Config{
2
    DataStore:  ldcomponents.PersistentDataStore(
3
      examplepackage.DataStore().SomeStoreOptions(),
4
    ),
5
    DataSource: ldcomponents.ExternalUpdatesOnly(),
6
}

1
{-# LANGUAGE OverloadedStrings #-}
2
3
import LaunchDarkly.Server.Config
4
5
import Data.Function ((&))
6
7
config :: Config
8
config = (makeConfig "YOUR_SDK_KEY")
9
    & configSetUseLdd true
10
    & configSetStoreBackend backend

1
LDConfig config = new LDConfig.Builder()
2
  .dataStore(
3
    Components.persistentDataStore(
4
      SomeDatabaseName.DataStore(storeOptions)
5
    )
6
  )
7
  .dataSource(Components.externalUpdatesOnly())
8
  .build();

1
import com.launchdarkly.sdk.server.*;
2
3
LDConfig config = new LDConfig.Builder()
4
    .dataSystem(
5
        Components.dataSystem().daemon(
6
            Components.persistentDataStore(Redis.dataStore())
7
        )
8
    )
9
    .build();
10
11
LDClient client = new LDClient("YOUR_SDK_KEY", config);

1
$client = new LaunchDarkly\LDClient("YOUR_SDK_KEY",
2
    [ 'feature_requester' => LaunchDarkly\Integrations\NameOfDatabase::featureRequester() ]);

1
store = SomeKindOfFeatureStore(store_options)
2
3
config = Config(
4
  feature_store=store,
5
  use_ldd=True)

1
store = SomeKindOfFeatureStore.new(storeOptions)
2
3
config = LaunchDarkly::Config.new(
4
  feature_store: store,
5
  use_ldd: true
6
)

1
require 'ldclient-rb'
2
3
store = SomeKindOfFeatureStore.new(storeOptions)
4
5
config = LaunchDarkly::Config.new(
6
  data_system_config: LaunchDarkly::DataSystem.daemon(store).build
7
)
8
9
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

1
use launchdarkly_server_sdk::{ConfigBuilder, PersistentDataStoreBuilder};
2
3
4
let persistent_store_factory = SomeKindOfFeatureStore.new(storeOptions)
5
let persistent_data_store_builder = PersistentDataStoreBuilder::new(Arc::new(persistent_store_factory));
6
7
let config = ConfigBuilder::new("sdk-key")
8
            .daemon_mode(true)
9
            .data_store(&builder)
10
            .build()
11
            .expect("config should build");