Private attributes

In the client-side .NET SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• When creating the LaunchDarkly Configuration object, you can call the AllAttributesPrivate method, which takes in a boolean parameter. If true, all context attributes except the kind and key are removed for all contexts before the SDK sends the context to LaunchDarkly.
• When creating the LaunchDarkly Configuration object, you can call the PrivateAttributes method, which takes any number of attribute names or slash-delimited paths to designated JSON properties within an attribute, such as /address/street. If any context has a custom or built-in attribute that matches one of these names, the SDK removes it before sending the context to LaunchDarkly.

You can also mark attributes as private when building the context object by calling Private() on the context builder.

For example:

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

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

In the Android SDK you can define private attributes for the entire LaunchDarkly client. When creating the LDConfig object, call the privateAttributes method, which takes in a set of custom or built-in attributes as a parameter. If any context has a custom or built-in attribute named in this set, the SDK removes it before sending the context to LaunchDarkly.

Here's how to configure private attributes:

LDConfig ldConfig = new LDConfig.Builder()
    .events(
        Components.sendEvents()
            .privateAttributes("name", "group")
    )
    .build();
COPY

You can also mark attributes as private when building the context object by using the private versions of the builder methods to set the attributes. For example:

LDContext context = LDContext.builder("context-key-123abc")
    .set("email", "sandy@example.com")
    .set("name", "Sandy")
    .set("group", "Microsoft")
    .privateAttributes("name", "group")
COPY

When the SDK sends this context back to LaunchDarkly, it removes the name and group attributes.

In the C/C++ SDK there are two ways to define private attributes for the LaunchDarkly client:

• When creating the LDConfig object, you can set the allAttributesPrivate value to true. When you do this, all user attributes except the key are removed before the SDK sends the user to LaunchDarkly.
• When creating the LDConfig object, you can configure a map of privateAttributeNames. If any user has a custom or built-in attribute named in this list, the SDK removes it before sending the user to LaunchDarkly.

struct LDConfig *config = LDConfigNew("mobile-key-123abc");
// Mark all attributes private
LDConfigSetAllAttributesPrivate(config, true);
COPY

To mark all user attributes except the key as private, use the allAttributesPrivate option:

const user = {
  key: 'user-key-123abc',
  name: 'Sandy Smith',
  email: 'sandy@example.com'
};
const client = LDElectron.initialize('client-side-id-123abc', user, {
  allAttributesPrivate: true
});
COPY

In the above example, the SDK removes the name and email attributes.

You can also specify an array of which attributes should be private with the privateAttributeNames option. You can configure this option on a per-user basis by specifying which attributes should be private in your user object.

This option is configured in both the user object and the configuration object:

const user = {
  key: 'user-key-123abc',
  name: 'Sandy Smith',
  email: 'sandy@example.com',
  privateAttributeNames: ['email']
};
const client = LDElectron.initialize('client-side-id-123abc', user, {
  privateAttributeNames: ['email']
});
COPY

In the above example, the SDK sends only the key and name back to LaunchDarkly.

In the Flutter SDK, you can define private attributes for the entire LaunchDarkly client. When you create the LDConfig object, you can call the privateAttributeNames method, which takes in a set of custom or built-in attributes as a parameter. If any user has a custom or built-in attribute named in this set, the SDK removes it before sending the user to LaunchDarkly.

Set<String> privateAttributes =
  { 'name' // built-in attribute
  , 'group' // custom attribute
  };
LDConfig ldConfig = new LDConfigBuilder()
    .privateAttributeNames(privateAttributes)
    .build();
COPY

You can also mark attributes as private when building the user object by using the private versions of the builder methods to set the attributes. For example:

LDUser user = LDUserBuilder('user-key-123abc')
    .email('sandy@example.com')
    .privateName('Jane')
    .privateCustom('group', LDValue.ofString('microsoft'))
    .build();
COPY

When the SDK sends this user back to LaunchDarkly, the name and group attributes are removed.

In the iOS SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• When creating the LDConfig object, you can set the allContextAttributesPrivate attribute to true.
• When creating the LDConfig object, you can set the privateContextAttributes property to a list of References, such as [Reference("name"), Reference("/address/state")]. If any context has a custom or built-in attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

You can also mark attributes as private on a particular LDContext instance, for example:

var contextBuilder = LDContextBuilder(key: "context-key-123abc")
contextBuilder.trySetValue("name", .string("Sandy"))
contextBuilder.trySetValue("group", .array([LDValue(stringLiteral: "microsoft")]))
contextBuilder.addPrivateAttribute(Reference("name"))
contextBuilder.addPrivateAttribute(Reference("group"))
let context = try contextBuilder.build().get()
COPY

To mark all attributes except the key as private in the JavaScript SDK, you can use the allAttributesPrivate option:

const context = {
  kind: 'user',
  key: 'user-key-123abc',
  name: 'Sandy Smith',
  email: 'sandy@example.com'
};
const ldclient = ld.initialize('client-side-id-123abc', context, options = {
  allAttributesPrivate: true
});
COPY

In the above example, the name and email attributes are removed.

You can configure this option either in the configuration object or in the context object, by specifying an array of attributes that should be private. In the configuration object, specify your array of attributes in the privateAttributes configuration option. In the context object, specify your array of attributes in the privateNames field of the reserved _meta property.

Here's how:

const context = {
  kind: 'user',
  key: 'context-key-123abc',
  name: 'Sandy Smith',
  email: 'sandy@example.com',
  _meta: {
    privateAttributes: ['email']
  }
};
const ldclient = ld.initialize('client-side-id-123abc', context, options = {
  privateAttributes: ['email']
});
COPY

In the above example, the SDK sends only the context's key and name back to LaunchDarkly.

To mark all user attributes except the key as private in the Node.js SDK, you can use the allAttributesPrivate option:

const context = {
  kind: 'user',
  key: 'user-key-123abc',
  name: 'Sandy Smith',
  email: 'sandy@example.com'
};
const client = ld.initialize('client-side-id-123abc', context, {
  allAttributesPrivate: true
});
COPY

You can also specify an array of which attributes should be private with the privateAttributes option. You can configure this option on a per-context basis by specifying which attributes should be private in your context object.

You can configure this option in both the context object and the configuration object:

const context = {
  kind: 'user',
  key: 'user-key-123abc',
  name: 'Sandy Smith',
  email: 'sandy@example.com'
  _meta: {
    privateAttributes: ['email']
  }
};
const client = ld.initialize('client-side-id-123abc', context, {
  privateAttributes: ['email']
});
COPY

In the above example, the SDK sends only the context key and name back to LaunchDarkly.

You can configure this option in the configuration object, to apply to all contexts, either for all attributes or some attributes:

const config = {
  mobileKey: 'mobile-key-123abc',
  allAttributesPrivate: true
};
await ldClient.configure(config, context);
COPY

To learn more, read allAttributesPrivate and privateAttributes on LDConfig.

You can also mark an attribute as private for a particular context:

const context = {
  kind: 'user',
  key: 'user-key-123abc',
  firstName: 'Sandy',
  lastName: 'Smith',
  email: 'sandy@example.com',
  address: {
    street: '123 Main St',
    city: 'Springfield'
  },
  _meta: {
    privateAttributes: ['email', '/address/street']
  }
};
COPY

For attributes that are objects, you can mark specific fields private, using the / delimiter followed by the attribute name, then the / delimiter followed by the JSON property within the value. In the example, the attribute "address": { "street": "Main St", "city": "Springfield" } has only the /address/street marked as private.

To mark specific attributes as private:

user.addPrivateAttribute(String)
COPY

In the server-side .NET SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• When creating the LaunchDarkly Configuration object, you can configure Events with AllAttributesPrivate, which takes in a boolean parameter. If true, the SDK removes all attributes for all contexts before sending the context to LaunchDarkly, except the key.
• Or, you can configure Events with PrivateAttributes, which takes any number of attribute names or slash-delimited paths to designated a JSON property within an attribute, such as /address/street. If any context has a custom or built-in attribute that matches one of these names, the SDK removes it before sending the context to LaunchDarkly.

You can also mark attributes as private when building the context object by calling Private() after setting the attribute on the context builder.

For example:

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

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

Optionally, you can configure the Apex SDK to treat some or all user attributes as private user attributes. You can use private user attributes for targeting, but they are redacted from the user data sent back to LaunchDarkly.

In the Apex SDK there are two ways to define private attributes for the LaunchDarkly client:

• When creating the LDConfig object, you can use setAllAttributesPrivate(true). When you do this, all user attributes, except the key, are redacted before the SDK sends the user to LaunchDarkly.

  Here's how:

  Java

  LDConfig config = new LDConfig.Builder()
      .setAllAttributesPrivate(true)
      .build();
  COPY

• You can also define private attribute names on a per-user basis.

  Here's how:

  Java

  Set<String> privateAttributes = new Set<String>();
  privateAttributes.add('firstName');
  LDUser user = new LDUser.Builder('user-key-123abc')
      .setFirstName('alice')
      .setPrivateAttributeNames(privateAttributes)
      .build();
  COPY

In the C/C++ SDK there are three ways to define private attributes for the LaunchDarkly client:

• When creating the LDConfig object, you can use LDConfigSetAllAttributesPrivate. When you do this, all user attributes (except the key) for the user are removed before the SDK sends the user to LaunchDarkly.

  For example:

  C/C++

  LDConfigSetAllAttributesPrivate(config, true);
  COPY

• When creating the LDConfig object, you can list specific private attributes with LDConfigAddPrivateAttribute. If any user has a custom or built-in attribute named in this list, the SDK removes it before sending the user to LaunchDarkly.

  Here's how:

  C/C++

  LDConfigAddPrivateAttribute(config, "email");
  COPY

• You can also define private attribute names on a per-user basis. For example:

  C/C++

  LDUserAddPrivateAttribute(user, "email");
  COPY

Here's how to set context attributes as private for all contexts:

ldclient:start_instance("sdk-key-123abc", your_instance, #{private_attributes => [email]})
COPY

Here's how to set context attributes as private for a specific context:

ContextWithPrivateAttributes = ldclient_context:set_private_attributes([<<"name">>, <<"/address/street">>],
        ldclient_context:set(<<"name">>, <<"Global Health Services">>,
        ldclient_context:set(<<"email">>, <<"info@globalhealthexample.com">>,
        ldclient_context:set(<<"address">>, #{
            <<"street">> => <<"123 Main Street">>,
            <<"city">> => <<"Springfield">>
        },
    ldclient_context:new(<<"context-key-456def">>, <<"organization">>))))),
COPY

In the example, only the name and /address/street attributes are private for this context.

In the Go SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• You can set the configuration option AllAttributesPrivate to true. If you enable this, the SDK removes all attributes for all contexts before it sends the context to LaunchDarkly, except the key and kind.
• You can set the configuration option PrivateAttributes to a list of attribute names. If any context has an attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

Here's how to to define private attributes:

import (
    ld "github.com/launchdarkly/go-server-sdk/v6"
    "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
)
var config ld.Config
// Make all attributes private for all contexts
config.Events = ldcomponents.SendEvents().AllAttributesPrivate(true)
// Or, make just the email and address attributes private for all contexts
config.Events = ldcomponents.SendEvents().
    PrivateAttributes("name", "email")
COPY

You can also define a set of private attributes on the context object itself. In the following example, "email" and the "street" field of the "address" attribute are private for this context, in addition to any private attributes that were specified globally:

import (
    "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
)
context := ldcontext.NewBuilder("context-key-123abc").
    Kind("organization").
    Name("Global Health Services").
    SetString("email", "info@globalhealthexample.com").
    SetValue("address", ldvalue.ObjectBuild().
        SetString("street", "123 Main Street").
        SetString("city", "Springfield")).
    Private("email").
    Private("/address/street").
    Build()
COPY

Optionally, you can configure the Haskell SDK to treat some or all context attributes as private attributes. You can use private context attributes for targeting purposes, but the SDK removes private context attributes from the data it sends to LaunchDarkly.

When you create the Config object, use configSetAllAttributesPrivate to set all context attributes as private. When you do this, all context attributes, except the key and kind, are removed before the SDK sends the context to LaunchDarkly.

Here's how:

makeConfig "sdk-key" & configSetAllAttributesPrivate True
COPY

When you create the Config object, you can list specific private attributes with configSetPrivateAttributeNames. If any context has attributes named in this list, the SDK removes them before sending the context to LaunchDarkly.

Here's an example:

import qualified Data.Set as S
import qualified LaunchDarkly.Server.Reference as R
makeConfig sdkKey
  & configSetAllAttributesPrivate True
  & configSetPrivateAttributeNames (S.fromList $ map R.makeLiteral ["name", "email"])
COPY

You can also define private attribute names on a per-context basis.

For example:

makeContext "key" "user"
  & withName "Sandy"
  & withAttribute "email" "sandy@example.com"
  & withPrivateAttributes (S.fromList $ map R.makeLiteral ["name", "email"])
COPY

In the Java SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• When creating the LDConfig object, you can call the allAttributesPrivate method, which takes in a boolean parameter. If true, all context attributes except the key for all contexts are removed before the SDK sends the context to LaunchDarkly.
• When creating the LDConfig object, you can call the privateAttributes method, which takes in a set of custom or built-in attributes as a parameter. If any context has a custom or built-in attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

Here's how to define private attributes:

LDConfig configWithAllAttributesPrivate = new LDConfig.Builder()
  .events(
    Components.sendEvents()
      .allAttributesPrivate(true)
  )
  .build();
LDConfig configWithSpecificAttributesPrivate = new LDConfig.Builder()
  .events(
    Components.sendEvents()
      .privateAttributes("name", "email", "someAttribute")
  )
  .build();
COPY

You can also mark attributes as private when building the context object by calling the privateAttributes builder method. For example:

LDContext context = LDContext.builder("context-key-123abc")
  .set("email", "sandy@example.com")
  .privateAttributes("email")
  .build();
COPY

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

Here's how to mark all attributes as private:

local user = ld.makeUser({
    allAttributesPrivate = true,
    key       = "user-key-123abc",
    firstName = "Sandy",
    lastName  = "Smith",
    email     = "sandy@example.com",
    custom    = {
        groups = { "Google", "Microsoft" }
    }
})
COPY

Here's how to mark only some attributes as private:

local user = ld.makeUser({
    key       = "user-key-123abc",
    firstName = "Sandy",
    lastName  = "Smith",
    email     = "sandy@example.com",
    custom    = {
        groups = { "Google", "Microsoft" }
    }
    privateAttributeNames = { "email" }
})
COPY

When the SDK sends this user back to LaunchDarkly, it removes the email attribute.

In the Node.js SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• In the LaunchDarkly LDOptions, you can set allAttributesPrivate to true. If you enable this, the SDK removes all attributes for all contexts before sending the context to LaunchDarkly, except the kind and key.
• In the LaunchDarkly LDOptions object, you can define a list of privateAttributes. If any context has a custom or built-in attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

You can also define a set of privateAttributes on the context object. For example:

const context = {
  kind: 'user',
  key: 'user-key-123abc',
  email: 'sandy@example.com',
  _meta: {
    privateAttributes: ['email'],
  }
};
COPY

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

In the PHP SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• In the LaunchDarkly config, you can set all_attributes_private to true. If you enable this, the SDK removes all attributes except the key and kind from a context before sending the context to LaunchDarkly.
• In the LaunchDarkly config object, you can define a list of private_attribute_names. If any context has a custom or built-in attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

You can also mark attributes as private when building the context object by calling the equivalent "private" LDContextBuilder method.

For example:

$context = LDContext::builder('context-key-123abc')
    ->set('email', 'sandy@example.com')
    ->private('email')
    ->build();
COPY

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

In the Python SDK there are two ways to define private attributes for the LaunchDarkly client:

• In the LaunchDarkly config, you can set all_attributes_private to true. If you enable this, the SDK removes all context attributes for all contexts before sending the context to LaunchDarkly, except the key.
• In the LaunchDarkly config object, you can define a list of attributes in private_attributes. If any context has a custom or built-in attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

You can also mark attributes as private when building the context object by calling the private builder method. For example:

context = Context.builder("context-key-123abc") \
    .set("email", "sandy@example.com") \
    .private("email") \
    .build()
COPY

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

In the Ruby SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• In the LaunchDarkly config, you can set all_attributes_private to true. If you enable this, the SDK removes all context attributes for all contexts before sending the context to LaunchDarkly, except the key.
• In the LaunchDarkly config object, you can define a list of private_attributes. If any context has a custom or built-in attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

You can also define a set of privateAttributes on the context object. For example:

context = LaunchDarkly::LDContext.create({
  key: "user-key-123abc",
  kind: "user",
  firstName: "Sandy",
  lastName: "Smith",
  email: "sandy@example.com",
  groups: ["Google", "Microsoft"],
  _meta: {
    privateAttributes: ['email']
  }
})
COPY

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.

In the Rust SDK there are two ways to define private attributes for the entire LaunchDarkly client:

• In the LaunchDarkly config object, you can set all_attributes_private to true. If you enable this, the SDK removes all attributes for all contexts before sending the context to LaunchDarkly, except the key and kind.
• In the LaunchDarkly config object, you can define a list of private_attributes. If any contexts has an attribute named in this list, the SDK removes it before sending the context to LaunchDarkly.

You can also define private attributes on the context object. For example:

let context = ContextBuilder::new("context-key-123abc")
    .set_value("email", "youremail@example.com".into())
    .add_private_attribute(Reference::new("email"))
    .build()?;
COPY

When the SDK sends this context back to LaunchDarkly, it removes the email attribute.