Data saving mode

1
using LaunchDarkly.Sdk.Server;
2
3
var config = Configuration.Builder("YOUR_SDK_KEY")
4
    .DataSystem(Components.DataSystem().Default())
5
    .Build();
6
7
var client = new LdClient(config);

1
using LaunchDarkly.Sdk.Server;
2
using LaunchDarkly.Sdk.Server.Integrations;
3
4
var relayUri = new Uri("http://my-relay-proxy:8030");
5
var relayEndpoints = Components.ServiceEndpoints().RelayProxy(relayUri);
6
7
var config = Configuration.Builder("YOUR_SDK_KEY")
8
    .DataSystem(
9
        Components.DataSystem().Custom()
10
            .Initializers(
11
                DataSystemComponents.Polling()
12
                    .ServiceEndpointsOverride(relayEndpoints),
13
                DataSystemComponents.Polling()
14
            )
15
            .Synchronizers(
16
                DataSystemComponents.Streaming()
17
                    .ServiceEndpointsOverride(relayEndpoints),
18
                DataSystemComponents.Streaming(),
19
                DataSystemComponents.Polling()
20
            )
21
    )
22
    .Build();
23
24
var client = new LdClient(config);

1
using LaunchDarkly.Sdk.Server;
2
using LaunchDarkly.Sdk.Server.Integrations;
3
4
var config = Configuration.Builder("YOUR_SDK_KEY")
5
    .DataSystem(
6
        Components.DataSystem().Custom()
7
            .Initializers(
8
                FileData.DataSource().FilePaths("flags.json"),
9
                DataSystemComponents.Polling()
10
            )
11
            .Synchronizers(
12
                DataSystemComponents.Streaming(),
13
                DataSystemComponents.Polling()
14
            )
15
    )
16
    .Build();
17
18
var client = new LdClient(config);

1
import (
2
    "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
3
    ld "github.com/launchdarkly/go-server-sdk/v7"
4
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
5
)
6
7
var config ld.Config
8
9
config.DataSystem = ldcomponents.DataSystem().Default()
10
11
client, _ := ld.MakeCustomClient("YOUR_SDK_KEY", config, 5*time.Second)

1
import (
2
    ld "github.com/launchdarkly/go-server-sdk/v7"
3
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
4
)
5
6
var config ld.Config
7
8
relayURI := "http://my-relay-proxy:8030"
9
10
config.DataSystem = ldcomponents.DataSystem().Custom().
11
    Initializers(
12
        ldcomponents.PollingDataSourceV2().BaseURI(relayURI).AsInitializer(),
13
        ldcomponents.PollingDataSourceV2().AsInitializer(),
14
    ).
15
    Synchronizers(
16
        ldcomponents.StreamingDataSourceV2().BaseURI(relayURI),
17
        ldcomponents.StreamingDataSourceV2(),
18
        ldcomponents.PollingDataSourceV2(),
19
    )
20
21
client, _ := ld.MakeCustomClient("YOUR_SDK_KEY", config, 5*time.Second)

1
import (
2
    ld "github.com/launchdarkly/go-server-sdk/v7"
3
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
4
    "github.com/launchdarkly/go-server-sdk/v7/ldfiledatav2"
5
)
6
7
var config ld.Config
8
9
config.DataSystem = ldcomponents.DataSystem().Custom().
10
    Initializers(
11
        ldfiledatav2.DataSource().FilePaths("flags.json").AsInitializer(),
12
        ldcomponents.PollingDataSourceV2().AsInitializer(),
13
    ).
14
    Synchronizers(
15
        ldcomponents.StreamingDataSourceV2(),
16
        ldcomponents.PollingDataSourceV2(),
17
    )
18
19
client, _ := ld.MakeCustomClient("YOUR_SDK_KEY", config, 5*time.Second)

1
import com.launchdarkly.sdk.server.*;
2
3
LDConfig config = new LDConfig.Builder()
4
    .dataSystem(Components.dataSystem().defaultMode())
5
    .build();
6
7
LDClient client = new LDClient("YOUR_SDK_KEY", config);

1
import com.launchdarkly.sdk.server.*;
2
import com.launchdarkly.sdk.server.integrations.*;
3
4
import java.net.URI;
5
6
URI relayUri = URI.create("http://my-relay-proxy:8030");
7
ServiceEndpointsBuilder relayEndpoints = Components.serviceEndpoints().relayProxy(relayUri);
8
9
LDConfig config = new LDConfig.Builder()
10
    .dataSystem(
11
        Components.dataSystem().custom()
12
            .initializers(
13
                DataSystemComponents.pollingInitializer()
14
                    .serviceEndpointsOverride(relayEndpoints),
15
                DataSystemComponents.pollingInitializer()
16
            )
17
            .synchronizers(
18
                DataSystemComponents.streamingSynchronizer()
19
                    .serviceEndpointsOverride(relayEndpoints),
20
                DataSystemComponents.streamingSynchronizer(),
21
                DataSystemComponents.pollingSynchronizer()
22
            )
23
    )
24
    .build();
25
26
LDClient client = new LDClient("YOUR_SDK_KEY", config);

1
import com.launchdarkly.sdk.server.*;
2
import com.launchdarkly.sdk.server.integrations.*;
3
4
LDConfig config = new LDConfig.Builder()
5
    .dataSystem(
6
        Components.dataSystem().custom()
7
            .initializers(
8
                FileData.initializer().filePaths("flags.json"),
9
                DataSystemComponents.pollingInitializer()
10
            )
11
            .synchronizers(
12
                DataSystemComponents.streamingSynchronizer(),
13
                DataSystemComponents.pollingSynchronizer()
14
            )
15
    )
16
    .build();
17
18
LDClient client = new LDClient("YOUR_SDK_KEY", config);

1
const ldClient = LaunchDarkly.init('YOUR_SDK_KEY', {
2
  dataSystem: {
3
    dataSource: {
4
        dataSourceOptionsType: 'standard',
5
6
        // if you use the stream, streamInitialReconnectDelay, or pollInterval options,
7
        // these options are now part of the dataSystem options,
8
        // and are set within the dataSource option
9
    }
10
    // if you use the persistentStore or useLDD option,
11
    // these options are now part of the dataSystem option
12
  }
13
});

1
const ldClient = LaunchDarkly.init('YOUR_SDK_KEY', {
2
  dataSystem: {
3
    dataSource: {
4
      dataSourceOptionsType: 'custom',
5
      initializers: [
6
        { type: 'file', paths: ['flags.json'] },
7
        { type: 'polling' },
8
      ],
9
      synchronizers: [
10
        { type: 'streaming' },
11
        { type: 'polling' },
12
      ],
13
    }
14
  }
15
});

1
import ldclient
2
from ldclient.config import Config
3
from ldclient import datasystem
4
5
ldclient.set_config(
6
    Config(
7
        "YOUR_SDK_KEY",
8
        datasystem_config=datasystem.default().build(),
9
    )
10
)
11
12
client = ldclient.get()

1
import ldclient
2
from ldclient.config import Config
3
from ldclient import datasystem
4
5
relay_uri = "http://my-relay-proxy:8030"
6
7
ldclient.set_config(
8
    Config(
9
        "YOUR_SDK_KEY",
10
        datasystem_config=datasystem.custom()
11
            .initializers([
12
                datasystem.polling_ds_builder().base_uri(relay_uri),
13
                datasystem.polling_ds_builder(),
14
            ])
15
            .synchronizers(
16
                datasystem.streaming_ds_builder().base_uri(relay_uri),
17
                datasystem.streaming_ds_builder(),
18
                datasystem.polling_ds_builder(),
19
            )
20
            .build(),
21
    )
22
)
23
24
client = ldclient.get()

1
import ldclient
2
from ldclient.config import Config
3
from ldclient import datasystem
4
5
ldclient.set_config(
6
    Config(
7
        "YOUR_SDK_KEY",
8
        datasystem_config=datasystem.custom()
9
            .initializers([
10
                datasystem.file_ds_builder(paths=["flags.json"]),
11
                datasystem.polling_ds_builder(),
12
            ])
13
            .synchronizers(
14
                datasystem.streaming_ds_builder(),
15
                datasystem.polling_ds_builder(),
16
            )
17
            .build(),
18
    )
19
)
20
21
client = ldclient.get()

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

1
require 'ldclient-rb'
2
3
relay_uri = "http://my-relay-proxy:8030"
4
5
config = LaunchDarkly::Config.new(
6
  data_system_config: LaunchDarkly::DataSystem.custom
7
    .initializers([
8
      LaunchDarkly::DataSystem.polling_ds_builder.base_uri(relay_uri),
9
      LaunchDarkly::DataSystem.polling_ds_builder,
10
    ])
11
    .synchronizers([
12
      LaunchDarkly::DataSystem.streaming_ds_builder.base_uri(relay_uri),
13
      LaunchDarkly::DataSystem.streaming_ds_builder,
14
      LaunchDarkly::DataSystem.polling_ds_builder,
15
    ])
16
    .build
17
)
18
19
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

1
require 'ldclient-rb'
2
3
config = LaunchDarkly::Config.new(
4
  data_system_config: LaunchDarkly::DataSystem.custom
5
    .initializers([
6
      LaunchDarkly::Integrations::FileData.data_source_v2(paths: ['flags.json']),
7
      LaunchDarkly::DataSystem.polling_ds_builder,
8
    ])
9
    .synchronizers([
10
      LaunchDarkly::DataSystem.streaming_ds_builder,
11
      LaunchDarkly::DataSystem.polling_ds_builder,
12
    ])
13
    .build
14
)
15
16
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

1
import { createClient } from '@launchdarkly/js-client-sdk';
2
3
const client = createClient('example-client-side-id', context, {
4
  dataSystem: {},
5
});

1
const client = createClient('example-client-side-id', context, {
2
  dataSystem: {
3
    automaticModeSwitching: { type: 'manual', initialConnectionMode: 'polling' },
4
  },
5
});

1
import { AutoEnvAttributes, ReactNativeLDClient } from '@launchdarkly/react-native-client-sdk';
2
3
const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, {
4
  dataSystem: {},
5
});

1
const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, {
2
  dataSystem: {
3
    automaticModeSwitching: false,
4
  },
5
});

1
import { createLDReactProvider } from '@launchdarkly/react-sdk';
2
3
export const LDReactProvider = createLDReactProvider('example-client-side-id', context, {
4
  ldOptions: { dataSystem: {} },
5
});

1
export const LDReactProvider = createLDReactProvider('example-client-side-id', context, {
2
  ldOptions: {
3
    dataSystem: { automaticModeSwitching: { type: 'manual', initialConnectionMode: 'polling' } },
4
  },
5
});