Storing data

The .NET SDK can use Consul, DynamoDB, or Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

using LaunchDarkly.Sdk.Server;
using LaunchDarkly.Sdk.Server.Integrations;
var config = Configuration.Builder(sdkKey)
    .DataStore(
        Components.PersistentDataStore(
            SomeDatabaseName.DataStore()
        )
    )
    .Build();
COPY

To learn more, read ConfigurationBuilder.DataStore.

To use a persistent feature store without connecting to LaunchDarkly, use the DataStore builder method as above, and then use Components.ExternalUpdatesOnly to configure daemon mode. To learn more, read Using daemon mode.

The C++ SDK can use Redis to hold flag data.

In the C++ SDK v3.0, you cannot use a persistent feature store while connecting to LaunchDarkly.

To use a persistent feature store without having the SDK connect to LaunchDarkly, use the LazyLoadBuilder. The SDK reads flag data from the persistent store lazily, in the background.

Here's how:

using LazyLoad = server_side::config::builders::LazyLoadBuilder;
auto config_builder = server_side::ConfigBuilder(sdk_key);
auto some_source = YourDatabaseIntegration();
config_builder.DataSystem().Method(
    LazyLoad().Source(some_source)
);
auto config = config_builder.Build();
if (!config) {
    /* an error occurred, config is not valid */
}
COPY

To learn more, read Using daemon mode and LazyLoadBuilder.

The Erlang SDK can use Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

LdOptions = #{
  feature_store => your_feature_store
},
ldclient:start_instance("sdk-key-123abc", LdOptions).
COPY

To use a persistent feature store without connecting to LaunchDarkly, set the feature_store property as above, and then set the use_ldd option to configure daemon mode. To learn more, read Using daemon mode.

The Go SDK can use Consul, DynamoDB, or Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

import (
    "time"
    ld "github.com/launchdarkly/go-server-sdk/v6"
    "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
    examplepackage "github.com/launchdarkly/go-server-sdk-some-example-database"
)
var config ld.Config
config.DataStore = ldcomponents.PersistentDataStore(
    examplepackage.DataStore().SomeStoreOptions(),
)
client, _ := ld.MakeCustomClient(sdkKey, config, 5*time.Second)
COPY

To learn more, read PersistentDataStore.

To use a persistent feature store without connecting to LaunchDarkly, use PersistentDataStore() as above, and then use ExternalUpdatesOnly() to configure daemon mode. To learn more, read Using daemon mode.

The Haskell SDK can use Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

import LaunchDarkly.Server
main = do
    backend <- makeYourBackendInterface
    let config = configSetStoreBackend backend $ makeConfig "sdk-key-123abc"
    client <- makeClient config
COPY

To use a persistent feature store without connecting to LaunchDarkly, use configSetStoreBackend as above, and then use configSetUseLdd to configure daemon mode. To learn more, read Using daemon mode.

The Java SDK can use Consul, DynamoDB, or Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

import com.launchdarkly.sdk.server.*;
import com.launchdarkly.sdk.server.integrations.*;
LDConfig config = new LDConfig.Builder()
  .dataStore(
    Components.persistentDataStore(
      SomeDatabaseName.dataStore(storeOptions)
    )
  )
  .build();
LDClient client = new LDClient(sdkKey, config);
COPY

To learn more, read Components.persistentDataStore.

To use a persistent feature store without connecting to LaunchDarkly, use persistentDataStore as above, and then use externalUpdatesOnly to configure daemon mode. To learn more, read Using daemon mode.

The Lua SDK can use Redis to hold flag data. The module launchdarkly_server_sdk_redis caches the feature flag data.

In the Lua SDK v2, you cannot use a persistent feature store while connecting to LaunchDarkly.

To use a persistent feature store without having the SDK connect to LaunchDarkly, specify a lazyLoad data source. The SDK reads flag data from the persistent store lazily, in the background.

Here's how:

local config = {
    dataSystem = {
        lazyLoad = {
            source = makeYourSource()
        }
    }
}
COPY

In the Lua SDK v1, you can use a feature store while connecting to LaunchDarkly.

local l = require("launchdarkly_server_sdk")
local backend = makeYourBackendInterface()
local c = l.clientInit({
    key                 = "sdk-key-123abc",
    featureStoreBackend = backend
)}
COPY

To learn more, read Using daemon mode.

The Node.js SDK can use Consul, DynamoDB, or Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

const ld = require('@launchdarkly/node-server-sdk');
const store = SomeKindOfFeatureStore(storeOptions);
const options = {
  featureStore: store
};
const client = ld.init('sdk-key-123abc', options);
COPY

To use a persistent feature store without connecting to LaunchDarkly, set the featureStore property as above, and then set the useLdd property to configure daemon mode. To learn more, read Using daemon mode.

The PHP SDK can use Consul, DynamoDB, or Redis to get flag data.

Unlike other server-side SDKs, the PHP SDK cannot connect to LaunchDarkly while using a database as a backing store. It can only read from a database that has been populated by the Relay Proxy, or by another application that uses a server-side LaunchDarkly SDK. To learn more, read Using daemon mode.

Another difference from other SDKs is that the PHP SDK does not have an in-memory cache for database queries. This is because in PHP, the entire in-memory application state is normally discarded after each request. Therefore, code examples for PHP do not include a cache TTL parameter.

To read from a persistent feature store without connecting to LaunchDarkly:

$client = new LaunchDarkly\LDClient("sdk-key-123abc", [
    'feature_requester' => LaunchDarkly\Integrations\NameOfDatabase::featureRequester()
]);
COPY

Prior to version 4.0, the database integrations were included in the main PHP SDK package. Starting in version 4.0, they are in separate packages.

The Python SDK can use Consul, DynamoDB, or Redis to hold flag data.

To use a persistent feature store while connecting to LaunchDarkly:

import ldclient
from ldclient.config import Config
store = SomeKindOfFeatureStore(store_options)
config = Config(feature_store=store)
ldclient.set_config(config)
COPY

To use a persistent feature store without connecting to LaunchDarkly, set the feature_store property as above, and then set the use_ldd property to configure daemon mode. To learn more, read Using daemon mode.

The Ruby SDK can use Consul, DynamoDB, or Redis to hold flag data.

These adapters are implemented in the LaunchDarkly::Integrations::Redis, LaunchDarkly::Integrations::DynamoDB, and LaunchDarkly::Integrations::Consul modules. To use them, call the new_feature_store method in the module, and put the returned object in the feature_store property of your client configuration.

To use a persistent feature store while connecting to LaunchDarkly:

require 'ldclient-rb'
store = SomeKindOfFeatureStore.new(storeOptions)
config = LaunchDarkly::Config.new(
  feature_store: store
)
client = LaunchDarkly::Client.new(sdk_key, config)
COPY

To use a persistent feature store without connecting to LaunchDarkly, set the feature_store property as above, and then set the use_ldd property to configure daemon mode. To learn more, read Using daemon mode.