Data saving mode

This topic explains how data saving mode works in the LaunchDarkly SDKs that support it.

Data saving mode is supported in the server-side 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.

Overview

This topic explains how data saving mode works in the LaunchDarkly SDKs that support it.

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.

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:

• .NET (server-side)
• Go
• Java
• Node.js (server-side)
• Python
• Ruby

.NET (server-side)

Expand .NET (server-side) SDK code sample

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. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.

4. 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 Launch

Darkly 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()
                  .Initializers(
                      DataSystemComponents.Polling()
                          .ServiceEndpointsOverride(relayEndpoints),
                      DataSystemComponents.Polling()
                  )
                  .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

Expand Go SDK code sample

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. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.

4. 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 Launch

Darkly 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().
          Initializers(
              ldcomponents.PollingDataSourceV2().BaseURI(relayURI).AsInitializer(),
              ldcomponents.PollingDataSourceV2().AsInitializer(),
          ).
          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

Expand Java SDK code sample

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. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.

4. 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 Launch

Darkly 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()
                  .initializers(
                      DataSystemComponents.pollingInitializer()
                          .serviceEndpointsOverride(relayEndpoints),
                      DataSystemComponents.pollingInitializer()
                  )
                  .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)

Expand Node.js (server-side) code sample

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. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.

4. 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

Expand Python SDK code sample

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. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.

4. 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 Launch

Darkly 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()
                  .initializers([
                      datasystem.polling_ds_builder().base_uri(relay_uri),
                      datasystem.polling_ds_builder(),
                  ])
                  .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

Expand Ruby SDK code sample

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. Request to join the Early Access Program. Wait to receive confirmation from LaunchDarkly that data saving mode is enabled for your account.

4. 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 Launch

Darkly 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
          .initializers([
            LaunchDarkly::DataSystem.polling_ds_builder.base_uri(relay_uri),
            LaunchDarkly::DataSystem.polling_ds_builder,
          ])
          .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.