Identifying and changing contexts

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify method tells the client to change the current context and obtain the feature flag values for the new context. In the .NET SDK, you can use either the Identify or IdentifyAsync method to switch contexts.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call Identify() or IdentifyAsync() so that the person receives the correct feature flag settings for their account.

In general, however, we recommend composing the new context as a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call Identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

You may want to wait until the flag values for the new context have been loaded before proceeding. You can do this either by calling the synchronous method Identify with a timeout, or by calling the asynchronous method IdentifyAsync and awaiting the result.

Here’s how:

1
var updatedContext = Context.Builder("context-key-123abc")
2
    .Set("email", "sandy@example.com")
3
    .Build();
4
5
// Synchronous method
6
client.Identify(updatedContext, TimeSpan.FromSeconds(5));
7
8
// Asynchronous method
9
await client.IdentifyAsync(updatedContext);

To learn more, read Identify and IdentifyAsync.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

Here’s how:

1
LDContext updatedContext = LDContext.builderFromContext(context)
2
    .email("sandy@example.com")
3
    .build();
4
5
client.identify(updatedContext);

The identify() call loads any saved flag values for the new user context and immediately triggers an update of the latest flags from LaunchDarkly.

identify() returns a Future to indicate completion. If you want to be sure subsequent code is using the latest values from the server, you can wait for the Future using get.

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call Identify so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call Identify with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

Here’s how to update your initial context when you have additional information:

1
/* before end user logs in */
2
auto context = ContextBuilder()
3
  .Kind("device", "device-key-123abc")
4
  .Build();
5
6
/* after end user logs in */
7
auto updated_context = ContextBuilder(context)
8
  .Kind("user", "user-key-123abc")
9
  .Name("Sandy")
10
  .Kind("organization", "org-key-123abc")
11
  .Name("Global Health Services")
12
  .Build();

After you update the context, you must call identify with the updated context in order to evaluate flags based on the updated information.

Here’s how to use the identify method to switch contexts:

1
client.IdentifyAsync(updated_context);

You can also examine the result to determine if the identification succeeded. Here’s how:

1
auto identify_result = client.IdentifyAsync(updated_context);
2
auto status = identify_result.wait_for(maxwait);
3
4
if (status == std::future_status::ready) {
5
  /* The client's attempt to identify succeeded or failed in the specified amount of time. */
6
  if (identify_result.get()) {
7
    /* Identification succeeded */
8
  } else {
9
    /* Identification failed */
10
  }
11
} else {
12
  /* The specified timeout was reached, but the client is still identifying. */
13
}

The IdentifyAsync call loads any saved flag values for the new context and immediately triggers an update of the latest flags from LaunchDarkly. Because this method re-fetches flag settings for the updated context, you should not call it at high frequency. The intended use case for switching contexts is the login/logout flow. To learn more, read IdentifyAsync.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

Here’s how:

1
const newUser = { key: 'user-key-123abc', name: 'Sandy' };
2
3
client.identify(newUser, (newFlags) => {
4
  console.log('value of flag for this user is: ' + newFlags['flag-key-123abc']);
5
  console.log('this should be the same: ' + client.variation('flag-key-123abc'));
6
});
7
8
// or:
9
client.identify(newUser).then((newFlags) => {
10
  // as above
11
});

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

Here’s how:

1
final updatedContext = LDContextBuilder()
2
  .kind('user', 'user-key-123abc')
3
  .setString('email', 'sandy@example.com'))
4
  .build();
5
6
await client.identify(updatedContext);

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

If the client app does not identify an LDContext, LDClient creates an anonymous default context, which can affect which feature flags LaunchDarkly delivers to the LDClient. Client apps should follow the Apple Privacy Policy when collecting end user information.

Here’s how:

1
let newContext = try LDContextBuilder(key: "context-key-123abc").build().get();
2
3
// You can also call identify with a completion
4
LDClient.get()!.identify(context: newContext) {
5
    // Flags have been retrieved for the new context
6
}

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

If you provide a callback function, it is called with a map of flag keys and values after the flag values for the new context are available. After that point, variation() uses the new values. You can also use a Promise for the same purpose.

Here’s how:

1
client.identify(newContext, hash, function() {
2
  console.log("New context's flags available");
3
});

To learn more, read identify.

If your contexts are extraordinarily large, you may need to configure the JavaScript SDK to send the evaluation context as a request body. To learn more, read Using REPORT in the JavaScript SDK.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

Here’s how:

1
client.identify(newContext, () => {
2
  console.log("New context's flags available");
3
});
4
5
// or, with a Promise:
6
client.identify(newContext).then(() => {
7
  console.log("New context's flags available");
8
});

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

Here’s how:

1
import { useLDClient } from 'launchdarkly-react-client-sdk';
2
3
let ldClient = useLDClient();
4
5
ldClient.identify(newContext, null, () => {
6
  console.log("New context's flags available");
7
});

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify method tells the client to change the current context and obtain the feature flag values for the new context.

If multiple customers use your app on a single device, you may want to change contexts and have separate flag settings for each one. To do this, the SDK stores contexts on a single device using react-native-async-storage, and supports switching between different contexts. You can use the identify method to switch contexts. identify loads any saved flag values for the new context and immediately triggers an update of the latest flags from LaunchDarkly.

You might also call identify when your app gathers additional information about the end user. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user. Then you can evaluate flags using attributes from all three context kinds together.

Here’s how:

1
import { useLDClient } from '@launchdarkly/react-native-client-sdk';
2
3
const client = useLDClient();
4
const context: LDContext = {'key': 'user-key-123abc', 'kind': 'user'};
5
    client
6
      .identify(context)
7
      .catch((e: any) => console.error(`error identifying ${context.key}: ${e}`));

To learn more, read identify.

Client-side SDKs are configured to operate for one context at a time, whether identified or anonymous. The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as a multi-context that combines a pre-login anonymous context and a post-login context with the “user” kind. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context based on multiple identifiers, rather than only pre- and post-login contexts. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of “device.” When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the “device,” “user,” and “organization” contexts for the end user.

To do this:

1
' before the end user logs in
2
device = {
3
  "kind": "device",
4
  "key": "device-key-123abc",
5
  "type": "tablet"
6
}
7
context = LaunchDarklyCreateContext(device)
8
9
' after the end user logs in
10
multi = {
11
  "kind": "multi",
12
  "device": device,
13
  "user": {"key": "user-key-123abc", "name": "Sandy"},
14
  "organization": {"key": "org-key-123abc", "name": "Acme, Inc."}
15
}
16
17
launchDarkly.identify(multi)

In server-side SDKs, Identify creates or updates contexts on LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call Identify. The Variation methods automatically create contexts on the Contexts list for you, using the context you pass to each Variation method. Identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use Identify:

1
client.Identify(context);

To learn more, read Identify.

In server-side SDKs, identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Users list.

To use identify:

1
client.identify(user);

To learn more, read Other methods.

In server-side SDKs, Identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call Identify. The variation call automatically creates contexts on the Contexts list for you, using the evaluation context you pass to each variation method. Identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use Identify:

1
client.Identify(context);

To learn more, read Identify() in Client.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create contexts on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
ldclient:identify(#{key => <<"context-key-123abc">>})

To learn more, read identify.

In server-side SDKs, Identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call Identify. The Variation method automatically creates contexts on the Contexts list for you, using the context you pass to each Variation method. Identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use Identify:

1
client.Identify(context)

To learn more, read Identify.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create contexts on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
identify client context

To learn more, read identify.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create contexts on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
client.identify(context);

To learn more, read identify.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create contexts on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
client:identify(context)

To learn more, read identify.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation call automatically creates users on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
client.identify(context);

To learn more, read identify.

In server-side SDKs, identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation call automatically creates contexts on the Contexts list for you, using the context you pass to each variation call. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
$client->identify($context);

To learn more, read identify.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation method automatically creates contexts on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
ldclient.get().identify(context)

To learn more, read identify.

In server-side SDKs, identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation call automatically creates contexts on the Contexts list for you, using the context you pass to each variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
client.identify(context)

To learn more, read identify.

In server-side SDKs, identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create users or contexts on the Contexts list for you, using the context you pass to each Variation method. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

1
client.identify(context);

To learn more, read identify.