Identifying and changing contexts

var updatedContext = Context.Builder("example-context-key")
    .Set("email", "sandy@example.com")
    .Build();

// Synchronous method
client.Identify(updatedContext, TimeSpan.FromSeconds(5));

// Asynchronous method
await client.IdentifyAsync(updatedContext);

LDContext updatedContext = LDContext.builderFromContext(context)
    .set("email", "sandy@example.com")
    .build();

client.identify(updatedContext);

val updatedContext: LDContext = LDContext.builderFromContext(context)
    .set("email", "sandy@example.com")
    .build()

client.identify(updatedContext)

/* before end user logs in */
auto context = ContextBuilder()
  .Kind("device", "example-device-key")
  .Build();

/* after end user logs in */
auto updated_context = ContextBuilder(context)
  .Kind("user", "example-user-key")
  .Name("Sandy")
  .Kind("organization", "example-organization-key")
  .Name("Global Health Services")
  .Build();

client.IdentifyAsync(updated_context);

LDClientSDK_Identify(client, updated_context, LD_NONBLOCKING, NULL);

auto identify_result = client.IdentifyAsync(updated_context);
auto status = identify_result.wait_for(maxwait);

if (status == std::future_status::ready) {
  /* The client's attempt to identify succeeded or failed in the specified amount of time. */
  if (identify_result.get()) {
    /* Identification succeeded */
  } else {
    /* Identification failed */
  }
} else {
  /* The specified timeout was reached, but the client is still identifying. */
}

bool identified_successfully;
if (LDClientSDK_Identify(client, updated_context, maxwait, &identified_successfully)) {
  /* The client's attempt to identify succeeded or failed in the specified amount of time. */
  if (identified_successfully) {
    /* Identification succeeded. */
  } else {
    /* Identification failed. */
  }
} else {
   /* The specified timeout was reached, but the client is still identifying. */
}

const newUser = { key: 'example-user-key', name: 'Sandy' };

client.identify(newUser, null, (err, newFlags) => {
  console.log('value of flag for this user is: ' + newFlags['example-flag-key']);
  console.log('this should be the same: ' + client.variation('example-flag-key'));
});

// or:
client.identify(newUser).then((newFlags) => {
  // as above
});

import * as LDElectron from 'launchdarkly-electron-client-sdk';

const newUser: LDElectron.LDUser = {
  key: 'someone-else', name: 'John',
};

client.identify(newUser, null, (err, newFlags) => {
  console.log('value of flag for this user is: ' + newFlags['example-flag-key']);
  console.log('this should be the same: ' + client.variation('example-flag-key'));
});

// or:
client.identify(newUser).then((newFlags) => {
  // as above
});

final updatedContext = LDContextBuilder()
  .kind('user', 'example-user-key')
  .setString('email', 'sandy@example.com')
  .build();

await client.identify(updatedContext);

final updatedMultiContext = LDContextBuilder()
  .kind('user', 'example-user-key')
  .kind('device', 'example-device-key')
  .build();

await client.identify(updatedMultiContext);

let newContext = try LDContextBuilder(key: "example-context-key").build().get()

LDClient.get()!.identify(context: newContext, timeout: 5) { result in
    switch result {
    case .complete:
        // Flags have been retrieved for the new context
        break
    case .timeout:
        // The identify request is still in progress
        break
    case .shed:
        // A later identify call replaced this one
        break
    case .error:
        // The identify request failed
        break
    }
}

LDContextBuilder *builder = [[LDContextBuilder alloc] initWithKey:@"example-context-key"];
ContextBuilderResult *result = builder.build;

if (result.success) {
    LDContext *newContext = result.success;

    [[LDClient get] identifyWithContext:newContext];

    // You can also call identify with a completion
    [[LDClient get] identifyWithContext:newContext completion:^() {
        // Flags have been retrieved for the new context
    }];
}

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

const newMultiContext = {
  kind: 'multi',
  user: {
    key: 'example-user-key',
    name: 'Anna',
    role: 'doctor'
  },
  device: {
    key: 'example-device-key',
    platform: 'Android'
  }
}

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

const result = await client.identify(newContext, { timeout: 5 });

if (result.status === 'completed') {
  console.log("New context's flags available");
} else if (result.status === 'shed') {
  // A later identify call replaced this one
} else {
  console.error(`identify did not complete: ${result.status}`);
}

client.identify(newContext, null, () => {
  console.log("New context's flags available");
});

// or, with a Promise:
client.identify(newContext).then(() => {
  console.log("New context's flags available");
});

const newMultiContext = {
  kind: 'multi',
  user: {
    key: 'aa0ceb',
    name: 'Anna',
    role: 'doctor'
  },
  device: {
    key: 'example-device-key',
    platform: 'Android'
  }
}

client.identify(newMultiContext, null, () => {
  console.log("New context's flags available");
});

// or, with a Promise:
client.identify(newMultiContext).then(() => {
  console.log("New context's flags available");
});

const result = await client.identify(newContext, { timeout: 5 });

if (result.status === 'completed') {
  console.log("New context's flags available");
} else if (result.status === 'shed') {
  // A later identify call replaced this one
} else {
  console.error(`identify did not complete: ${result.status}`);
}

import { useLDClient } from 'launchdarkly-react-client-sdk';

let ldClient = useLDClient();

ldClient.identify(newContext, null, () => {
  console.log("New context's flags available");
});

import { useLDClient } from '@launchdarkly/react-native-client-sdk';

const client = useLDClient();
const context: LDContext = {'key': 'example-user-key', 'kind': 'user'};
    client
      .identify(context)
      .catch((e: any) => console.error(`error identifying ${context.key}: ${e}`));

<script setup>
import { useLDClient } from '@launchdarkly/vue-client-sdk'

const ldClient = useLDClient()

async function signIn(userKey) {
  await ldClient.identify({ kind: 'user', key: userKey })
  // The variation composables re-evaluate automatically.
}
</script>

<script setup>
import { useLDClient } from '@launchdarkly/vue-client-sdk'

const ldClient = useLDClient()

async function signIn() {
  await ldClient.identify({
    kind: 'multi',
    user: {
      key: 'example-user-key',
      name: 'Anna',
      role: 'doctor'
    },
    device: {
      key: 'example-device-key',
      platform: 'Android'
    }
  })
  // The variation composables re-evaluate automatically.
}
</script>

<script setup>
import { onScopeDispose } from 'vue'
import { useLDClient } from '@launchdarkly/vue-client-sdk'

const ldClient = useLDClient()

// onContextChange returns a function that unsubscribes the callback.
const unsubscribe = ldClient.onContextChange((context) => {
  console.log('context changed:', context)
})

onScopeDispose(unsubscribe)
</script>

client.Identify(context);

client.identify(user);

client.Identify(context);

LDServerSDK_Identify(client, context);

ldclient:identify(#{key => <<"example-context-key">>})

// There is not an Identify method in the LDScopedClient,
// so you need to access the method from the LDClient.
// Then, pass in the scoped client's current context.
// LDScopedClient is in beta and may change without notice.
scopedClient.Client().Identify(scopedClient.CurrentContext())

client.Identify(context)

identify client context

client.identify(context);

client:identify(context)

client.identify(context);

$client->identify($context);

ldclient.get().identify(context)

client.identify(context)

client.identify(context);