Caching contexts to local storage

If you set bootstrap to the string "localStorage", the client tries to get flag values from persistent storage, using a unique key that is based on the user properties.

In Electron, persistent storage consists of files in the userData directory. If the client finds flag values stored for this user, it uses them and starts up immediately in a ready state, but also makes a background request to LaunchDarkly to get the latest values and stores them as soon as it receives them.

You can choose to enable caching to local storage, but you cannot configure the cache size.

Here’s how to use this mode:

1
const client = LaunchDarkly.initializeInMain(
2
  'example-client-side-id',
3
  user,
4
  {
5
    bootstrap: 'localStorage'
6
  }
7
);

If you enable local storage you cannot also provide bootstrap flag values. To learn more, read Bootstrapping.

The JavaScript client SDK v4.x stores flag values for unique contexts in local storage by default, with no configuration required. You can optionally set the maximum number of unique contexts cached locally by setting maxCachedContexts at startup.

To learn more, read Interface LDOptions.

JavaScript SDK v3.x requires you to enable caching contexts to local storage at initialization using the bootstrap option, and does not provide the ability to configure the cache size.

Here is an example of how to configure caching to local storage with JavaScript:

1
import { createClient } from '@launchdarkly/js-client-sdk';
2
3
const context = { kind: 'user', key: 'example-user-key'};
4
5
// Local storage is enabled by default
6
// You can optionally configure the maximum number of cached contexts (default is 5)
7
const options = { maxCachedContexts: 3 };
8
9
const client = createClient(
10
  'example-client-side-id',
11
  context,
12
  options
13
);
14
15
client.start();

If you enable local storage with JavaScript SDK v3.x, you cannot also provide bootstrap flag values. To learn more, read Bootstrapping.

The Node.js (client-side) SDK requires you to configure local storage caching using the bootstrap option. In this mode, if no values have been cached yet, the SDK obtains flags from LaunchDarkly and then caches them in persistent storage. The next time you start, the cached flags are immediately available, and the SDK also contacts LaunchDarkly in the background to obtain updated values.

You can choose to enable caching to local storage, but you cannot configure the cache size.

To activate this mode, use the special string "localStorage":

1
const client = LDClient.initialize(
2
  'example-client-side-id',
3
  context,
4
  {
5
    bootstrap: 'localStorage'
6
  }
7
);

If you enable local storage you cannot also provide bootstrap flag values. To learn more, read Bootstrapping.

The React Native SDK stores flag values for unique contexts in AsyncStorage by default, with no configuration required. You can optionally set the maximum number of unique contexts cached locally by setting maxCachedContexts at startup.

To learn more, read Interface LDOptions.

Here is an example of how to configure caching to local storage with React Native:

1
import { ReactNativeLDClient, AutoEnvAttributes } from '@launchdarkly/react-native-client-sdk';
2
3
// Local storage is enabled by default using AsyncStorage
4
// You can optionally configure the maximum number of cached contexts (default is 5)
5
const options = { maxCachedContexts: 3 };
6
7
const client = new ReactNativeLDClient(
8
  'example-mobile-key',
9
  AutoEnvAttributes.Enabled,
10
  options
11
);
12
13
await client.start();

The iOS SDK stores flag values for unique contexts in local storage by default, with no configuration required. You can optionally set the maximum number of unique contexts cached locally by setting maxCachedContexts on your LDConfig before starting the client.

To learn more, read Struct LDConfig.

Here is an example of how to configure caching to local storage with iOS:

1
var config = LDConfig(mobileKey: "example-mobile-key", autoEnvAttributes: .enabled)
2
3
// Local storage is enabled by default
4
// You can optionally configure the maximum number of cached contexts (default is 5)
5
config.maxCachedContexts = 3
6
7
let contextBuilder = LDContextBuilder(key: "example-context-key")
8
guard case .success(let context) = contextBuilder.build() else { return }
9
10
LDClient.start(config: config, context: context)

The Android SDK stores flag values for unique contexts in SharedPreferences by default, with no configuration required. You can optionally set the maximum number of unique contexts cached locally by setting maxCachedContexts in your LDConfig before starting the client.

To learn more, read Class LDConfig.Builder.

Here is an example of how to configure caching to local storage with Android:

1
LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
2
    .mobileKey("example-mobile-key")
3
    // Local storage is enabled by default
4
    // You can optionally configure the maximum number of cached contexts (default is 5)
5
    .maxCachedContexts(3)
6
    .build();
7
8
LDContext context = LDContext.create("example-context-key");
9
10
LDClient client = LDClient.init(this.getApplication(), ldConfig, context, 0);

The Flutter SDK stores flag values for unique contexts in on-device storage by default, with no configuration required. You can optionally set the maximum number of unique contexts cached locally by setting maxCachedContexts in a PersistenceConfig passed to your LDConfig.

To learn more, read Class PersistenceConfig.

Here is an example of how to configure caching to local storage with Flutter:

1
// Local storage is enabled by default
2
// You can optionally configure the maximum number of cached contexts (default is 5)
3
final config = LDConfig(
4
  'example-mobile-key',
5
  AutoEnvAttributes.enabled,
6
  persistence: PersistenceConfig(maxCachedContexts: 3),
7
);
8
9
final context = LDContextBuilder()
10
  .kind('user', 'example-context-key')
11
  .build();
12
13
final client = LDClient(config, context);
14
await client.start();

The React Web SDK stores flag values for unique contexts in local storage by default, with no configuration required. You can optionally set the maximum number of unique contexts cached locally by setting maxCachedContexts inside ldOptions when you create your provider.

To learn more, read Interface LDReactClientOptions.

Here is an example of how to configure caching to local storage with React Web:

1
import { createLDReactProvider } from '@launchdarkly/react-sdk';
2
3
const context = { kind: 'user', key: 'example-user-key' };
4
5
// Local storage is enabled by default
6
// You can optionally configure the maximum number of cached contexts (default is 5)
7
const LDProvider = createLDReactProvider(
8
  'example-client-side-id',
9
  context,
10
  {
11
    ldOptions: {
12
      maxCachedContexts: 3,
13
    },
14
  }
15
);