SDKsSDK features

Data saving mode

Data saving mode is available for Early Access

Data saving mode is supported in the SDKs listed below. It is also supported in the Relay Proxy.

Data saving mode is only available to members of LaunchDarkly’s Early Access Program (EAP). If you want access to this feature, join the EAP.

This topic explains how data saving mode works in the LaunchDarkly SDKs that support it, listed below. The Relay Proxy also supports data saving mode.

Server-side SDKs in data saving mode first open a polling connection to LaunchDarkly. The initial payload from this connection contains the data the SDK will need to operate and perform flag evaluations.

Subsequently, server-side SDKs in data saving mode open a streaming connection and receive realtime flag configuration changes over the stream. These configuration changes include only the difference between the server-side SDK’s stored configuration and the latest configuration in LaunchDarkly. The SDKs use in-memory data for the unchanged aspects of the flag configuration.

The SDKs fall back to using a polling connection if LaunchDarkly streaming is unavailable. Data saving mode includes additional configuration options that let you set a backup data source, enabling automatic failover if a connection is unavailable.

Depending on the number of flags in your project and the complexity of their configuration, data saving mode can significantly improve performance, including reducing your network costs when in polling mode or on reconnection. Additionally, SDKs in data saving mode have reduced memory and CPU usage overall.

Track service connection usage by application

When using data saving mode, you can track which applications are consuming service connections by configuring application metadata. Set the applicationId in your SDK configuration to see a per-application breakdown on the Service connections usage page under the SDK App ID dimension. Server-side streaming connections without applicationId configured appear as “Unknown.” To learn how, read Application metadata configuration.

Server-side SDKs

This feature is available in the following SDKs:

File initializers provide startup data but do not initialize the SDK

When you configure a custom data source, a file initializer provides an initial set of flag data so your application can begin evaluating flags at startup. However, the SDK itself does not reach an initialized state from using the file initializer alone. The SDK is fully initialized only after it uses a streaming or polling synchronizer to connect to LaunchDarkly and obtain a complete set of flag data.

The examples in this topic all pair a file initializer with a synchronizer. If you configure a file initializer without a synchronizer, your flags still load and evaluate correctly, but the SDK does not report itself as initialized. In this case, evaluate flags directly without gating your application’s startup on the SDK initialization status. As a best practice, we recommend not blocking application startup on SDK initialization in any configuration, so your application can start in a degraded but functional state and rely on fallback values until the SDK is ready.

A file initializer reads the same file format as the file-based data source, including the flags and flagValues formats. To learn about the file format, read Reading flags from a file.

.NET (server-side)

To enable data saving mode:

  1. If you are using the Relay Proxy, upgrade your Relay Proxy to version 9.0.0-rc.1 or later.
  2. Upgrade your .NET (server-side) SDK to version 8.11 or later.
  3. Update your SDK configuration to enable the DataSystem configuration option.

Here’s how to enable the DataSystem configuration option:

Standard setup

.NET (server-side) SDK v8.11+
using LaunchDarkly.Sdk.Server;
var config = Configuration.Builder("YOUR_SDK_KEY")
    .DataSystem(Components.DataSystem().Default())
    .Build();
var client = new LdClient(config);

We recommend the standard data system configuration for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

Relay proxy with LaunchDarkly API fallback

.NET (server-side) SDK v8.11+
using LaunchDarkly.Sdk.Server;
using LaunchDarkly.Sdk.Server.Integrations;
var relayUri = new Uri("http://my-relay-proxy:8030");
var relayEndpoints = Components.ServiceEndpoints().RelayProxy(relayUri);
var config = Configuration.Builder("YOUR_SDK_KEY")
    .DataSystem(
        Components.DataSystem().Custom()
            .Synchronizers(
                DataSystemComponents.Streaming()
                    .ServiceEndpointsOverride(relayEndpoints),
                DataSystemComponents.Streaming(),
                DataSystemComponents.Polling()
            )
    )
    .Build();
var client = new LdClient(config);

File-based bootstrap with live updates

.NET (server-side) SDK v8.11+
using LaunchDarkly.Sdk.Server;
using LaunchDarkly.Sdk.Server.Integrations;
var config = Configuration.Builder("YOUR_SDK_KEY")
    .DataSystem(
        Components.DataSystem().Custom()
            .Initializers(
                FileData.DataSource().FilePaths("flags.json"),
                DataSystemComponents.Polling()
            )
            .Synchronizers(
                DataSystemComponents.Streaming(),
                DataSystemComponents.Polling()
            )
    )
    .Build();
var client = new LdClient(config);

To learn more, read DataSystemModes for information about pre-configured data system modes, and DataSystemBuilder for information on additional configuration options.

Go

To enable data saving mode:

  1. If you are using the Relay Proxy, upgrade your Relay Proxy to version 9.0.0-rc.1 or later.
  2. Upgrade your Go SDK to version 7.11 or later.
  3. Update your SDK configuration to enable the DataSystem configuration option.

Here’s how to enable the DataSystem configuration option:

Standard setup

Go SDK v7.11+
import (
    "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
    ld "github.com/launchdarkly/go-server-sdk/v7"
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
)
var config ld.Config
config.DataSystem = ldcomponents.DataSystem().Default()
client, _ := ld.MakeCustomClient("YOUR_SDK_KEY", config, 5*time.Second)

We recommend the standard data system configuration for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

Relay proxy with LaunchDarkly API fallback

Go SDK v7.11+
import (
    ld "github.com/launchdarkly/go-server-sdk/v7"
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
)
var config ld.Config
relayURI := "http://my-relay-proxy:8030"
config.DataSystem = ldcomponents.DataSystem().Custom().
    Synchronizers(
        ldcomponents.StreamingDataSourceV2().BaseURI(relayURI),
        ldcomponents.StreamingDataSourceV2(),
        ldcomponents.PollingDataSourceV2(),
    )
client, _ := ld.MakeCustomClient("YOUR_SDK_KEY", config, 5*time.Second)

File-based bootstrap with live updates

Go SDK v7.11+
import (
    ld "github.com/launchdarkly/go-server-sdk/v7"
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
    "github.com/launchdarkly/go-server-sdk/v7/ldfiledatav2"
)
var config ld.Config
config.DataSystem = ldcomponents.DataSystem().Custom().
    Initializers(
        ldfiledatav2.DataSource().FilePaths("flags.json").AsInitializer(),
        ldcomponents.PollingDataSourceV2().AsInitializer(),
    ).
    Synchronizers(
        ldcomponents.StreamingDataSourceV2(),
        ldcomponents.PollingDataSourceV2(),
    )
client, _ := ld.MakeCustomClient("YOUR_SDK_KEY", config, 5*time.Second)

To learn more, read DataSystem. For information on additional configuration options, read DataSystemConfiguration.

Java

To enable data saving mode:

  1. If you are using the Relay Proxy, upgrade your Relay Proxy to version 9.0.0-rc.1 or later.
  2. Upgrade your Java (server-side) SDK to version 7.11 or later.
  3. Update your SDK configuration to enable the dataSystem configuration option.

Here’s how to enable the dataSystem configuration option:

Standard setup

Java SDK v7.11+
import com.launchdarkly.sdk.server.*;
LDConfig config = new LDConfig.Builder()
    .dataSystem(Components.dataSystem().defaultMode())
    .build();
LDClient client = new LDClient("YOUR_SDK_KEY", config);

We recommend the default data system configuration for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

Relay proxy with LaunchDarkly API fallback

Java SDK v7.11+
import com.launchdarkly.sdk.server.*;
import com.launchdarkly.sdk.server.integrations.*;
import java.net.URI;
URI relayUri = URI.create("http://my-relay-proxy:8030");
ServiceEndpointsBuilder relayEndpoints = Components.serviceEndpoints().relayProxy(relayUri);
LDConfig config = new LDConfig.Builder()
    .dataSystem(
        Components.dataSystem().custom()
            .synchronizers(
                DataSystemComponents.streamingSynchronizer()
                    .serviceEndpointsOverride(relayEndpoints),
                DataSystemComponents.streamingSynchronizer(),
                DataSystemComponents.pollingSynchronizer()
            )
    )
    .build();
LDClient client = new LDClient("YOUR_SDK_KEY", config);

File-based bootstrap with live updates

Java SDK v7.11+
import com.launchdarkly.sdk.server.*;
import com.launchdarkly.sdk.server.integrations.*;
LDConfig config = new LDConfig.Builder()
    .dataSystem(
        Components.dataSystem().custom()
            .initializers(
                FileData.initializer().filePaths("flags.json"),
                DataSystemComponents.pollingInitializer()
            )
            .synchronizers(
                DataSystemComponents.streamingSynchronizer(),
                DataSystemComponents.pollingSynchronizer()
            )
    )
    .build();
LDClient client = new LDClient("YOUR_SDK_KEY", config);

To learn more, read DataSystemModesfor information about pre-configured data system modes, and DataSystemBuilder for information on additional configuration options.

Node.js (server-side)

To enable data saving mode:

  1. If you are using the Relay Proxy, upgrade your Relay Proxy to version 9.0.0-rc.1 or later.
  2. Upgrade your Node.js (server-side) SDK to version 9.10 or later.
  3. Update your SDK configuration:
    • Enable the dataSystem configuration option.
    • Migrate existing LDOptions fields. The following existing options were previously top-level LDOptions fields and are part of the dataSystem configuration as of version 9.10: persistentStore, stream, streamInitialReconnectDelay, pollInterval, useLDD.

Here’s how to enable the dataSystem configuration option:

Standard setup

Node.js (server-side) SDK v9.10+
const ldClient = LaunchDarkly.init('YOUR_SDK_KEY', {
  dataSystem: {
    dataSource: {
        dataSourceOptionsType: 'standard',
        // if you use the stream, streamInitialReconnectDelay, or pollInterval options,
        // these options are now part of the dataSystem options,
        // and are set within the dataSource option
    }
    // if you use the persistentStore or useLDD option,
    // these options are now part of the dataSystem option
  }
});

We recommend the standard data source option for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

File-based bootstrap with live updates

Node.js (server-side) SDK v9.10+
const ldClient = LaunchDarkly.init('YOUR_SDK_KEY', {
  dataSystem: {
    dataSource: {
      dataSourceOptionsType: 'custom',
      initializers: [
        { type: 'file', paths: ['flags.json'] },
        { type: 'polling' },
      ],
      synchronizers: [
        { type: 'streaming' },
        { type: 'polling' },
      ],
    }
  }
});

To learn more, read dataSystem. For information on additional configuration options, read LDDataSystemOptions.

Python

To enable data saving mode:

  1. If you are using the Relay Proxy, upgrade your Relay Proxy to version 9.0.0-rc.1 or later.
  2. Upgrade your Python SDK to version 9.13 or later.
  3. Update your SDK configuration to enable the DataSystem configuration option.

Here’s how to enable the DataSystem configuration option:

Standard setup

Python SDK v9.13+
import ldclient
from ldclient.config import Config
from ldclient import datasystem
ldclient.set_config(
    Config(
        "YOUR_SDK_KEY",
        datasystem_config=datasystem.default().build(),
    )
)
client = ldclient.get()

We recommend the standard data system configuration for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

Relay proxy with LaunchDarkly API fallback

Python SDK v9.13+
import ldclient
from ldclient.config import Config
from ldclient import datasystem
relay_uri = "http://my-relay-proxy:8030"
ldclient.set_config(
    Config(
        "YOUR_SDK_KEY",
        datasystem_config=datasystem.custom()
            .synchronizers(
                datasystem.streaming_ds_builder().base_uri(relay_uri),
                datasystem.streaming_ds_builder(),
                datasystem.polling_ds_builder(),
            )
            .build(),
    )
)
client = ldclient.get()

File-based bootstrap with live updates

Python SDK v9.13+
import ldclient
from ldclient.config import Config
from ldclient import datasystem
ldclient.set_config(
    Config(
        "YOUR_SDK_KEY",
        datasystem_config=datasystem.custom()
            .initializers([
                datasystem.file_ds_builder(paths=["flags.json"]),
                datasystem.polling_ds_builder(),
            ])
            .synchronizers(
                datasystem.streaming_ds_builder(),
                datasystem.polling_ds_builder(),
            )
            .build(),
    )
)
client = ldclient.get()

To learn more, read ldclient.datasystem. For information on additional configuration options, read DataSystemConfig.

Ruby

To enable data saving mode:

  1. If you are using the Relay Proxy, upgrade your Relay Proxy to version 9.0.0-rc.1 or later.
  2. Upgrade your Ruby SDK to version 8.12.0 or later.
  3. Update your SDK configuration to enable the data_system_config configuration option.

Here’s how to enable the data_system_config configuration option:

Standard setup

Ruby SDK v8.12.0+
require 'ldclient-rb'
config = LaunchDarkly::Config.new(
  data_system_config: LaunchDarkly::DataSystem.default.build
)
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

We recommend the standard data system configuration for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

Relay proxy with LaunchDarkly API fallback

Ruby SDK v8.12.0+
require 'ldclient-rb'
relay_uri = "http://my-relay-proxy:8030"
config = LaunchDarkly::Config.new(
  data_system_config: LaunchDarkly::DataSystem.custom
    .synchronizers([
      LaunchDarkly::DataSystem.streaming_ds_builder.base_uri(relay_uri),
      LaunchDarkly::DataSystem.streaming_ds_builder,
      LaunchDarkly::DataSystem.polling_ds_builder,
    ])
    .build
)
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

File-based bootstrap with live updates

Ruby SDK v8.12.0+
require 'ldclient-rb'
config = LaunchDarkly::Config.new(
  data_system_config: LaunchDarkly::DataSystem.custom
    .initializers([
      LaunchDarkly::Integrations::FileData.data_source_v2(paths: ['flags.json']),
      LaunchDarkly::DataSystem.polling_ds_builder,
    ])
    .synchronizers([
      LaunchDarkly::DataSystem.streaming_ds_builder,
      LaunchDarkly::DataSystem.polling_ds_builder,
    ])
    .build
)
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

To learn more, read LaunchDarkly::DataSystem. To learn more about additional configuration options, read DataSystem::ConfigBuilder.

Client-side SDKs

Client-side SDKs in data saving mode use the same data system pipeline as server-side SDKs, adapted to the lifecycle and connectivity characteristics of the client environment. SDKs may switch between connection modes automatically in response to application lifecycle events and network state changes. Some client-side SDKs use streaming when the application is active or in the foreground for real-time flag updates, and switch to polling or reduce activity when the application is backgrounded or hidden.

This feature is available in the following SDKs:

Android

Consider mobile update tails before shipping EAP code

Mobile applications have long update tails. Apps you ship today may remain installed on end-user devices for years. If you include the EAP version of the Android Client SDK in a production release, the EAP-era API surface and behaviors may persist in deployed apps long after data saving mode graduates to General Availability. Make sure your release timeline can tolerate shipping a non-stable API.

To enable data saving mode:

  1. Upgrade your Android Client SDK to version 5.13 or later.
  2. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.
  3. Update your SDK configuration to enable the dataSystem configuration option.

Here’s how to enable the dataSystem configuration option:

Standard setup

val config = LDConfig.Builder(AutoEnvAttributes.Enabled)
    .mobileKey("example-mobile-key")
    .dataSystem(Components.dataSystem())
    .build()

We recommend the standard data system configuration for most customers. It uses a combination of streaming and polling to initialize the SDK, provide real time updates, and switch between streaming and polling automatically to provide redundancy.

Automatic mode switching

The Android Client SDK switches between connection modes automatically based on app lifecycle and network connectivity. You can disable automatic switching entirely, or selectively disable lifecycle-driven or network-driven switching.

To disable automatic switching entirely and keep the SDK in a single connection mode regardless of lifecycle or network changes:

val config = LDConfig.Builder(AutoEnvAttributes.Enabled)
    .mobileKey("example-mobile-key")
    .dataSystem(
        Components.dataSystem()
            .automaticModeSwitching(AutomaticModeSwitchingConfig.disabled())
            .foregroundConnectionMode(ConnectionMode.STREAMING))
    .build()

To disable lifecycle-driven switching but continue switching modes when network connectivity changes:

val config = LDConfig.Builder(AutoEnvAttributes.Enabled)
    .mobileKey("example-mobile-key")
    .dataSystem(
        Components.dataSystem()
            .automaticModeSwitching(
                DataSystemComponents.automaticModeSwitching()
                    .lifecycle(false)
                    .network(true)
                    .build()))
    .build()

To learn more, read Components.dataSystem(). To learn more about additional configuration options, read DataSystemBuilder.

Flutter

Consider mobile update tails before shipping EAP code

Mobile applications have long update tails. Apps you ship today may remain installed on end-user devices for years. If you include the EAP version of the Flutter SDK in a production release, the EAP-era API surface and behaviors may persist in deployed apps long after data saving mode graduates to General Availability. Make sure your release timeline can tolerate shipping a non-stable API.

To enable data saving mode:

  1. Upgrade your Flutter SDK to version 4.20 or later.
  2. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.
  3. Update your SDK configuration to enable the dataSystem configuration option.

Here’s how to enable the dataSystem configuration option:

Standard setup

Flutter SDK v4.20+
final config = LDConfig(
  CredentialSource.fromEnvironment(),
  AutoEnvAttributes.enabled,
  dataSystem: const DataSystemConfig(),
);

We recommend the standard data system configuration for most customers. The Flutter SDK uses streaming in the foreground for real-time flag updates and reduces activity in the background, and switches between connection modes automatically as the app moves between the foreground and background.

Set a fixed connection mode

To keep the SDK in a single connection mode instead of letting it manage the connection, set the initial connection mode. This applies as a sticky override that suppresses automatic mode switching until you clear it with setConnectionMode:

Flutter SDK v4.20+
final config = LDConfig(
  CredentialSource.fromEnvironment(),
  AutoEnvAttributes.enabled,
  dataSystem: const DataSystemConfig(
    initialConnectionMode: ConnectionModeId.polling,
  ),
);

To learn more, read the launchdarkly_flutter_client_sdk API documentation.

JavaScript

To enable data saving mode:

  1. Upgrade your JavaScript SDK to version 4.9 or later.
  2. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.
  3. Update your SDK configuration to enable the dataSystem configuration option.

Here’s how to enable the dataSystem configuration option:

Standard setup

JavaScript SDK v4.9+
import { createClient } from '@launchdarkly/js-client-sdk';
const client = createClient('example-client-side-id', context, {
  dataSystem: {},
});

We recommend the standard data system configuration for most customers. The JavaScript SDK opens a streaming connection for real-time flag updates, and falls back to polling when streaming is unavailable.

Set a fixed connection mode

To keep the SDK in a single connection mode instead of letting it manage the connection, use manual mode switching and set the initial connection mode:

JavaScript SDK v4.9+
const client = createClient('example-client-side-id', context, {
  dataSystem: {
    automaticModeSwitching: { type: 'manual', initialConnectionMode: 'polling' },
  },
});

To learn more, read LDOptions.dataSystem.

React Native

Consider mobile update tails before shipping EAP code

Mobile applications have long update tails. Apps you ship today may remain installed on end-user devices for years. If you include the EAP version of the React Native SDK in a production release, the EAP-era API surface and behaviors may persist in deployed apps long after data saving mode graduates to General Availability. Make sure your release timeline can tolerate shipping a non-stable API.

To enable data saving mode:

  1. Upgrade your React Native SDK to version 10.19 or later.
  2. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.
  3. Update your SDK configuration to enable the dataSystem configuration option.

Here’s how to enable the dataSystem configuration option:

Standard setup

React Native SDK v10.19+
import { AutoEnvAttributes, ReactNativeLDClient } from '@launchdarkly/react-native-client-sdk';
const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, {
  dataSystem: {},
});

We recommend the standard data system configuration for most customers. The React Native SDK uses streaming in the foreground for real-time flag updates and polling in the background, and switches between connection modes automatically as the app moves between the foreground and background.

Automatic mode switching

By default, the React Native SDK switches between connection modes automatically based on app lifecycle. To disable automatic switching entirely and keep the SDK in a single connection mode regardless of lifecycle changes:

React Native SDK v10.19+
const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, {
  dataSystem: {
    automaticModeSwitching: false,
  },
});

To learn more, read LDOptions.dataSystem.

React Web

The React Web SDK is built on the JavaScript SDK, so it supports the same dataSystem configuration. Pass the option through the provider’s ldOptions.

To enable data saving mode:

  1. Upgrade your React Web SDK to version 4.2 or later.
  2. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.
  3. Update your SDK configuration to enable the dataSystem configuration option.

Here’s how to enable the dataSystem configuration option:

Standard setup

React Web SDK v4.2+
import { createLDReactProvider } from '@launchdarkly/react-sdk';
export const LDReactProvider = createLDReactProvider('example-client-side-id', context, {
  ldOptions: { dataSystem: {} },
});

We recommend the standard data system configuration for most customers. The React Web SDK opens a streaming connection for real-time flag updates, and falls back to polling when streaming is unavailable.

Set a fixed connection mode

To keep the SDK in a single connection mode instead of letting it manage the connection, use manual mode switching and set the initial connection mode:

React Web SDK v4.2+
export const LDReactProvider = createLDReactProvider('example-client-side-id', context, {
  ldOptions: {
    dataSystem: { automaticModeSwitching: { type: 'manual', initialConnectionMode: 'polling' } },
  },
});

To learn more, read LDReactClientOptions.

Vue

The Vue SDK relies on the JavaScript SDK for data saving mode, so it supports the same dataSystem configuration. Set the option in ldOptions when you install the plugin or create a provider.