Créer des indicateurs de fonctionnalité

Les indicateurs de fonctionnalité vous permettent d’activer ou de désactiver à distance des fonctionnalités pour une sélection d’utilisateurs. Créez un indicateur de fonctionnalité dans le tableau de bord de Braze. Donnez-lui un nom et un ID, une audience cible et un pourcentage d’utilisateurs pour lesquels activer cette fonctionnalité. Ensuite, en utilisant ce même ID dans le code de votre application ou de votre site web, vous pouvez exécuter certaines parties de votre logique métier de manière conditionnelle. Pour en savoir plus sur les indicateurs de fonctionnalité et leur utilisation dans Braze, consultez la section À propos des indicateurs de fonctionnalité.

Prérequis

Version du SDK

Pour utiliser les feature flags, assurez-vous que vos SDK sont à jour avec au moins ces versions minimales :

Autorisations Braze

Pour gérer les feature flags dans le tableau de bord, vous devrez être administrateur ou disposer des autorisations suivantes :

Créer un feature flag

Étape 1 : Créer un nouveau feature flag

Accédez à Messaging > Feature Flags, puis sélectionnez Create Feature Flag.

Étape 2 : Remplir les détails

Sous Feature flag details, saisissez un nom, un ID et une description pour votre feature flag.

Étape 2a : Créer des propriétés personnalisées

Sous Properties, vous pouvez éventuellement créer des propriétés personnalisées auxquelles votre application peut accéder via le SDK Braze lorsque votre fonctionnalité est activée. Vous pouvez attribuer une valeur de type chaîne de caractères, booléen, image, horodatage, JSON ou nombre à chaque variable, ainsi que définir une valeur par défaut.

• exemple

Dans l’exemple suivant, le feature flag affiche une bannière de rupture de stock pour une boutique e-commerce en utilisant les propriétés personnalisées répertoriées :

Nom de la propriété	Type	Valeur
banner_height	number	75
banner_color	string	blue
banner_text	string	Widgets are out of stock until July 1.
dismissible	boolean	false
homepage_icon	image	http://s3.amazonaws.com/[bucket_name]/
account_start	timestamp	2011-01-01T12:00:00Z
footer_settings	JSON	{ "colors": [ "red", "blue", "green" ], "placement": 123 }

Conseil

Il n’y a pas de limite au nombre de propriétés que vous pouvez ajouter. Cependant, les propriétés d’un feature flag sont limitées à un total de 10 000 caractères.

Étape 4 : Choisir les segments à cibler

Avant de déployer un feature flag, vous devez choisir un Segment d’utilisateurs à cibler. Sélectionnez Add Rule sur votre flag nouvellement créé, puis utilisez le groupe de filtres et les menus déroulants de Segments pour exclure des utilisateurs de votre audience cible. Ajoutez plusieurs filtres pour affiner davantage votre audience.

Étape 5 : Définir le trafic de déploiement

Par défaut, les feature flags sont toujours inactifs, ce qui vous permet de séparer la date de publication de votre fonctionnalité de l’activation totale des utilisateurs. Pour commencer votre déploiement, utilisez la section Rollout Traffic pour saisir un pourcentage dans le champ de texte. Cela déterminera le pourcentage d’utilisateurs aléatoires dans votre Segment sélectionné qui recevront cette nouvelle fonctionnalité.

Important

Ne définissez pas votre trafic de déploiement au-dessus de 0 % tant que vous n’êtes pas prêt à lancer votre nouvelle fonctionnalité. Lorsque vous définissez initialement votre feature flag dans le tableau de bord, laissez ce paramètre à 0 %.

Important

Pour déployer un flag avec une seule règle ou pour une audience unique, ajoutez votre première règle avec les critères de segmentation et les pourcentages de déploiement sélectionnés. Enfin, confirmez que la règle Everyone Else est désactivée, puis enregistrez votre flag.

Déploiements de feature flags multi-règles

Utilisez les déploiements de feature flags multi-règles pour définir une séquence de règles d’évaluation des utilisateurs, ce qui permet une segmentation précise et des lancements de fonctionnalités contrôlés. Cette méthode est idéale pour déployer la même fonctionnalité auprès d’audiences diverses.

Ordre d’évaluation

Les règles de feature flags sont évaluées de haut en bas, dans l’ordre où elles sont listées. Un utilisateur est qualifié par la première règle qu’il remplit. Si un utilisateur ne remplit aucune règle, son éligibilité est déterminée par la règle par défaut « Everyone Else ».

Qualification des utilisateurs

• Si un utilisateur remplit les critères de la première règle, il est immédiatement éligible pour recevoir le feature flag.
• Si un utilisateur ne se qualifie pas pour la première règle, il est évalué par rapport à la deuxième règle, et ainsi de suite.

L’évaluation séquentielle se poursuit jusqu’à ce qu’un utilisateur se qualifie pour une règle ou atteigne la règle « Everyone Else » en bas de la liste.

Règle « Everyone Else »

La règle « Everyone Else » fait office de règle par défaut. Si un utilisateur ne se qualifie pour aucune des règles précédentes, son éligibilité au feature flag sera déterminée par le paramètre de la règle « Everyone Else ». Par exemple, si la règle « Everyone Else » est basculée sur « Off », dans l’état par défaut, un utilisateur qui ne remplit les critères d’aucune autre règle ne recevra pas le feature flag au démarrage de sa session.

Réorganisation des règles

Par défaut, les règles sont classées dans l’ordre de leur création, mais vous pouvez les réorganiser par glisser-déposer dans le tableau de bord.

Cas d’usage des feature flags multi-règles

Déployer progressivement une page de paiement

Imaginons que vous travaillez pour une marque e-commerce et que vous disposez d’une nouvelle page de paiement que vous souhaitez déployer dans différentes zones géographiques pour garantir la stabilité. En utilisant les feature flags multi-règles, vous pouvez définir les paramètres suivants :

• Règle 1 : Votre Segment pour les États-Unis est défini à 100 %.
• Règle 2 : Votre Segment est défini à 50 % de vos utilisateurs brésiliens, de sorte que tous ne reçoivent pas le flux en même temps.
• Règle 3 (Everyone Else) : Pour tous les autres utilisateurs, activez votre règle « Everyone Else » et définissez-la à 15 %, afin qu’une partie de l’ensemble des utilisateurs puisse finaliser leur achat avec le nouveau flux.

Atteindre d’abord les testeurs internes

Imaginons que vous êtes chef de produit et que vous souhaitez vous assurer que vos testeurs internes reçoivent toujours le feature flag lorsque vous lancez un nouveau produit. Vous pouvez ajouter votre Segment de testeurs internes à votre première règle et le définir à 100 %, afin que vos testeurs internes soient éligibles à chaque déploiement de fonctionnalité.

Utilisation du champ « enabled » pour vos indicateurs de fonctionnalité

Une fois votre indicateur de fonctionnalité défini, configurez votre application ou votre site pour vérifier s’il est activé ou non pour un utilisateur donné. Lorsqu’il est activé, vous définirez une action ou référencerez les propriétés variables de l’indicateur de fonctionnalité en fonction de votre cas d’usage. Le SDK Braze fournit des méthodes getter pour récupérer l’état de l’indicateur de fonctionnalité et ses propriétés dans votre application.

Les indicateurs de fonctionnalité sont actualisés automatiquement au début de la session, afin que vous puissiez afficher la version la plus récente de votre fonctionnalité au moment du lancement. Le SDK met ces valeurs en cache pour qu’elles puissent être utilisées hors ligne.

Remarque

Veillez à enregistrer les impressions des indicateurs de fonctionnalité.

Imaginons que vous souhaitiez déployer un nouveau type de profil utilisateur pour votre application. Vous pouvez définir l’ID comme expanded_user_profile. Ensuite, votre application vérifie si elle doit afficher ce nouveau profil utilisateur à un utilisateur particulier. Par exemple :

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
6
const featureFlag = braze.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6
let featureFlag = braze.featureFlags.featureFlag(id: "expanded_user_profile")
if featureFlag?.enabled == true {
  print("expanded_user_profile is enabled")
} else {
  print("expanded_user_profile is not enabled")
}

1
2
3
4
5
6
FeatureFlag featureFlag = braze.getFeatureFlag("expanded_user_profile");
if (featureFlag != null && featureFlag.getEnabled()) {
  Log.i(TAG, "expanded_user_profile is enabled");
} else {
  Log.i(TAG, "expanded_user_profile is not enabled");
}

1
2
3
4
5
6
val featureFlag = braze.getFeatureFlag("expanded_user_profile")
if (featureFlag?.enabled == true) {
  Log.i(TAG, "expanded_user_profile is enabled.")
} else {
  Log.i(TAG, "expanded_user_profile is not enabled.")
}

1
2
3
4
5
6
const featureFlag = await Braze.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6
var featureFlag = Appboy.AppboyBinding.GetFeatureFlag("expanded_user_profile");
if (featureFlag != null && featureFlag.Enabled) {
  Console.WriteLine("expanded_user_profile is enabled");
} else {
  Console.WriteLine("expanded_user_profile is not enabled");
}

1
2
3
4
5
6
const featureFlag = await BrazePlugin.getFeatureFlag("expanded_user_profile");
if (featureFlag?.enabled) {
  console.log(`expanded_user_profile is enabled`);
} else {
  console.log(`expanded_user_profile is not enabled`);
}

1
2
3
4
5
6
BrazeFeatureFlag? featureFlag = await braze.getFeatureFlagByID("expanded_user_profile");
if (featureFlag?.enabled == true) {
  print("expanded_user_profile is enabled");
} else {
  print("expanded_user_profile is not enabled");
}

1
2
3
4
5
6
featureFlag = m.braze.getFeatureFlag("expanded_user_profile")
if featureFlag <> invalid and featureFlag.enabled
  print "expanded_user_profile is enabled"
else
  print "expanded_user_profile is not enabled"
end if

Enregistrement de l’impression d’un indicateur de fonctionnalité

Enregistrez une impression d’indicateur de fonctionnalité chaque fois qu’un utilisateur a eu l’occasion d’interagir avec votre nouvelle fonctionnalité, ou lorsqu’il aurait pu interagir si la fonctionnalité était désactivée (dans le cas d’un groupe de contrôle lors d’un test A/B). Les impressions des indicateurs de fonctionnalité ne sont enregistrées qu’une seule fois par session.

En général, vous pouvez placer cette ligne de code directement sous l’endroit où vous faites référence à votre indicateur de fonctionnalité dans votre application :

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
braze.logFeatureFlagImpression("expanded_user_profile");

1
braze.featureFlags.logFeatureFlagImpression(id: "expanded_user_profile")

1
braze.logFeatureFlagImpression("expanded_user_profile");

1
braze.logFeatureFlagImpression("expanded_user_profile")

1
Braze.logFeatureFlagImpression("expanded_user_profile");

1
Appboy.AppboyBinding.LogFeatureFlagImpression("expanded_user_profile");

1
BrazePlugin.logFeatureFlagImpression("expanded_user_profile");

1
braze.logFeatureFlagImpression("expanded_user_profile");

1
m.Braze.logFeatureFlagImpression("expanded_user_profile");

Accès aux propriétés

Pour accéder aux propriétés d’un indicateur de fonctionnalité, utilisez l’une des méthodes suivantes en fonction du type que vous avez défini dans le tableau de bord.

Si aucune propriété de ce type n’existe pour la clé que vous avez fournie, ces méthodes renverront null.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
const featureFlag = braze.getFeatureFlag("expanded_user_profile");

// Returns the String property
const stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
const booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
const numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
const imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a FeatureFlagJsonPropertyValue
const jsonProperty = featureFlag.getJsonProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
let featureFlag: FeatureFlag = braze.featureFlags.featureFlag(id: "expanded_user_profile")

// Returns the string property
let stringProperty: String? = featureFlag.stringProperty(key: "color")

// Returns the boolean property
let booleanProperty: Bool? = featureFlag.boolProperty(key: "expanded")

// Returns the number property as a double
let numberProperty: Double? = featureFlag.numberProperty(key: "height")

// Returns the Unix UTC millisecond timestamp property as an integer
let timestampProperty: Int? = featureFlag.timestampProperty(key: "account_start")

// Returns the image property as a String of the image URL
let imageProperty: String? = featureFlag.imageProperty(key: "homepage_icon")

// Returns the JSON object property as a [String: Any] dictionary
let jsonObjectProperty: [String: Any]? = featureFlag.jsonObjectProperty(key: "footer_settings")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
FeatureFlag featureFlag = braze.getFeatureFlag("expanded_user_profile");

// Returns the String property
String stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
Boolean booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
Number numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as a long
Long timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
String imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a JSONObject
JSONObject jsonObjectProperty = featureFlag.getJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
val featureFlag = braze.getFeatureFlag("expanded_user_profile")

// Returns the String property
val stringProperty: String? = featureFlag.getStringProperty("color")

// Returns the boolean property
val booleanProperty: Boolean? = featureFlag.getBooleanProperty("expanded")

// Returns the number property
val numberProperty: Number? = featureFlag.getNumberProperty("height")

// Returns the Unix UTC millisecond timestamp property as a long
val timestampProperty: Long? = featureFlag.getTimestampProperty("account_start")

// Returns the image property as a String of the image URL
val imageProperty: String?  = featureFlag.getImageProperty("homepage_icon")

// Returns the JSON object property as a JSONObject
val jsonObjectProperty: JSONObject? = featureFlag.getJSONProperty("footer_settings")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Returns the String property
const stringProperty = await Braze.getFeatureFlagStringProperty("expanded_user_profile", "color");

// Returns the boolean property
const booleanProperty = await Braze.getFeatureFlagBooleanProperty("expanded_user_profile", "expanded");

// Returns the number property
const numberProperty = await Braze.getFeatureFlagNumberProperty("expanded_user_profile", "height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = await Braze.getFeatureFlagTimestampProperty("expanded_user_profile", "account_start");

// Returns the image property as a String of the image URL
const imageProperty = await Braze.getFeatureFlagImageProperty("expanded_user_profile", "homepage_icon");

// Returns the JSON object property as an object
const jsonObjectProperty = await Braze.getFeatureFlagJSONProperty("expanded_user_profile", "footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Returns the Feature Flag instance
var featureFlag = Appboy.AppboyBinding.GetFeatureFlag("expanded_user_profile");

// Returns the String property
var stringProperty = featureFlag.GetStringProperty("color");

// Returns the boolean property
var booleanProperty = featureFlag.GetBooleanProperty("expanded");

// Returns the number property as an integer
var integerProperty = featureFlag.GetIntegerProperty("height");

// Returns the number property as a double
var doubleProperty = featureFlag.GetDoubleProperty("height");

// Returns the Unix UTC millisecond timestamp property as a long
var timestampProperty = featureFlag.GetTimestampProperty("account_start");

// Returns the image property as a String of the image URL
var imageProperty = featureFlag.GetImageProperty("homepage_icon");

// Returns the JSON object property as a JSONObject
var jsonObjectProperty = featureFlag.GetJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Returns the String property
const stringProperty = await BrazePlugin.getFeatureFlagStringProperty("expanded_user_profile", "color");

// Returns the boolean property
const booleanProperty = await BrazePlugin.getFeatureFlagBooleanProperty("expanded_user_profile", "expanded");

// Returns the number property
const numberProperty = await BrazePlugin.getFeatureFlagNumberProperty("expanded_user_profile", "height");

// Returns the Unix UTC millisecond timestamp property as a number
const timestampProperty = await BrazePlugin.getFeatureFlagTimestampProperty("expanded_user_profile", "account_start");

// Returns the image property as a String of the image URL
const imageProperty = await BrazePlugin.getFeatureFlagImageProperty("expanded_user_profile", "homepage_icon");

// Returns the JSON object property as an object
const jsonObjectProperty = await BrazePlugin.getFeatureFlagJSONProperty("expanded_user_profile", "footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Returns the Feature Flag instance
BrazeFeatureFlag featureFlag = await braze.getFeatureFlagByID("expanded_user_profile");

// Returns the String property
var stringProperty = featureFlag.getStringProperty("color");

// Returns the boolean property
var booleanProperty = featureFlag.getBooleanProperty("expanded");

// Returns the number property
var numberProperty = featureFlag.getNumberProperty("height");

// Returns the Unix UTC millisecond timestamp property as an integer
var timestampProperty = featureFlag.getTimestampProperty("account_start");

// Returns the image property as a String of the image URL
var imageProperty = featureFlag.getImageProperty("homepage_icon");

// Returns the JSON object property as a Map<String, dynamic> collection
var jsonObjectProperty = featureFlag.getJSONProperty("footer_settings");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
' Returns the String property
color = featureFlag.getStringProperty("color")

' Returns the boolean property
expanded = featureFlag.getBooleanProperty("expanded")

' Returns the number property
height = featureFlag.getNumberProperty("height")

' Returns the Unix UTC millisecond timestamp property
account_start = featureFlag.getTimestampProperty("account_start")

' Returns the image property as a String of the image URL
homepage_icon = featureFlag.getImageProperty("homepage_icon")

' Returns the JSON object property
footer_settings = featureFlag.getJSONProperty("footer_settings")

Obtenir la liste de tous les indicateurs de fonctionnalité

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
const features = getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4
let features = braze.featureFlags.featureFlags
for let feature in features {
  print("Feature: \(feature.id)", feature.enabled)
}

1
2
3
4
List<FeatureFlag> features = braze.getAllFeatureFlags();
for (FeatureFlag feature: features) {
  Log.i(TAG, "Feature: ", feature.getId(), feature.getEnabled());
}

1
2
3
4
val featureFlags = braze.getAllFeatureFlags()
featureFlags.forEach { feature ->
  Log.i(TAG, "Feature: ${feature.id} ${feature.enabled}")
}

1
2
3
4
const features = await Braze.getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4
List<FeatureFlag> features = Appboy.AppboyBinding.GetAllFeatureFlags();
foreach (FeatureFlag feature in features) {
  Console.WriteLine("Feature: {0} - enabled: {1}", feature.ID, feature.Enabled);
}

1
2
3
4
const features = await BrazePlugin.getAllFeatureFlags();
for(const feature of features) {
  console.log(`Feature: ${feature.id}`, feature.enabled);
}

1
2
3
4
List<BrazeFeatureFlag> featureFlags = await braze.getAllFeatureFlags();
featureFlags.forEach((feature) {
  print("Feature: ${feature.id} ${feature.enabled}");
});

1
2
3
4
features = m.braze.getAllFeatureFlags()
for each feature in features
      print "Feature: " + feature.id + " enabled: " + feature.enabled.toStr()
end for

Actualisation des indicateurs de fonctionnalité

Vous pouvez actualiser les indicateurs de fonctionnalité de l’utilisateur actuel en cours de session pour récupérer les dernières valeurs depuis Braze.

Conseil

L’actualisation se produit automatiquement au début de la session. Elle n’est nécessaire qu’avant des actions importantes de l’utilisateur, comme avant de charger une page de paiement, ou si vous savez qu’un indicateur de fonctionnalité sera référencé.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku

1
2
3
4
5
braze.refreshFeatureFlags(() => {
  console.log(`Feature flags have been refreshed.`);
}, () => {
  console.log(`Failed to refresh feature flags.`);
});

1
2
3
4
5
6
7
8
braze.featureFlags.requestRefresh { result in
  switch result {
  case .success(let features):
    print("Feature flags have been refreshed:", features)
  case .failure(let error):
    print("Failed to refresh feature flags:", error)
  }
}

1
braze.refreshFeatureFlags();

1
braze.refreshFeatureFlags()

1
Braze.refreshFeatureFlags();

1
Appboy.AppboyBinding.RefreshFeatureFlags();

1
BrazePlugin.refreshFeatureFlags();

1
braze.refreshFeatureFlags();

1
m.Braze.refreshFeatureFlags()

Écoute des changements

Vous pouvez configurer le SDK Braze pour qu’il écoute et mette à jour votre application lorsque le SDK actualise des indicateurs de fonctionnalité.

Cela est utile si vous souhaitez mettre à jour votre application lorsqu’un utilisateur n’est plus éligible à une fonctionnalité. Par exemple, pour définir un état dans votre application en fonction de l’activation ou non d’une fonctionnalité, ou de l’une de ses valeurs de propriété.

• web
• swift
• android
• react native
• unity
• cordova
• flutter
• roku
• react hook

1
2
3
4
5
6
// Register an event listener
const subscriptionId = braze.subscribeToFeatureFlagsUpdates((features) => {
  console.log(`Features were updated`, features);
});
// Unregister this event listener
braze.removeSubscription(subscriptionId);

1
2
3
4
5
6
7
// Create the feature flags subscription
// - You must keep a strong reference to the subscription to keep it active
let subscription = braze.featureFlags.subscribeToUpdates { features in
  print("Feature flags were updated:", features)
}
// Cancel the subscription
subscription.cancel()

1
2
3
4
5
6
braze.subscribeToFeatureFlagsUpdates(event -> {
  Log.i(TAG, "Feature flags were updated.");
  for (FeatureFlag feature: event.getFeatureFlags()) {
    Log.i(TAG, "Feature: ", feature.getId(), feature.getEnabled());
  }
});

1
2
3
4
5
6
braze.subscribeToFeatureFlagsUpdates() { event ->
  Log.i(TAG, "Feature flags were updated.")
  event.featureFlags.forEach { feature ->
    Log.i(TAG, "Feature: ${feature.id}")
  }
}

1
2
3
4
// Register an event listener
Braze.addListener(braze.Events.FEATURE_FLAGS_UPDATED, (featureFlags) => {
  console.log(`featureFlagUpdates`, JSON.stringify(featureFlags));
});

1
2
3
4
// Register an event listener
BrazePlugin.subscribeToFeatureFlagUpdates((featureFlags) => {
    console.log(`featureFlagUpdates`, JSON.stringify(featureFlags));
});

1
2
3
4
5
6
7
8
9
// Create stream subscription
StreamSubscription featureFlagsStreamSubscription;

featureFlagsStreamSubscription = braze.subscribeToFeatureFlags((featureFlags) {
  print("Feature flags were updated");
});

// Cancel stream subscription
featureFlagsStreamSubscription.cancel();

1
2
' Define a function called `onFeatureFlagChanges` to be called when feature flags are refreshed
m.BrazeTask.ObserveField("BrazeFeatureFlags", "onFeatureFlagChanges")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import { useEffect, useState } from "react";
import {
  FeatureFlag,
  getFeatureFlag,
  removeSubscription,
  subscribeToFeatureFlagsUpdates,
} from "@braze/web-sdk";

export const useFeatureFlag = (id: string): FeatureFlag => {
  const [featureFlag, setFeatureFlag] = useState<FeatureFlag>(
    getFeatureFlag(id)
  );

  useEffect(() => {
    const listener = subscribeToFeatureFlagsUpdates(() => {
      setFeatureFlag(getFeatureFlag(id));
    });
    return () => {
      removeSubscription(listener);
    };
  }, [id]);

  return featureFlag;
};

Vérifier l’éligibilité des utilisateurs

Pour vérifier à quels feature flags un utilisateur est éligible dans Braze, accédez à Audience > Rechercher des utilisateurs, puis recherchez et sélectionnez un utilisateur.

Dans l’onglet Éligibilité aux feature flags, vous pouvez filtrer la liste des feature flags éligibles par plateforme, application ou appareil. Vous pouvez également prévisualiser le payload qui sera renvoyé à l’utilisateur en sélectionnant à côté d’un feature flag.

Consulter le journal des modifications

Pour consulter le journal des modifications d’un feature flag, ouvrez un feature flag et sélectionnez Changelog.

Vous pouvez y consulter la date d’une modification, la personne qui l’a effectuée, la catégorie à laquelle elle appartient, et bien plus encore.

Segmentation avec les indicateurs de fonctionnalité

Braze garde automatiquement la trace des utilisateurs pour lesquels un indicateur de fonctionnalité est actuellement activé. Vous pouvez créer un segment ou cibler un envoi de messages à l’aide du filtre Indicateur de fonctionnalité. Pour plus d’informations sur le filtrage des segments, consultez Créer un segment.

Remarque

Pour éviter les segments récursifs, il n’est pas possible de créer un segment faisant référence à d’autres indicateurs de fonctionnalité.

Bonnes pratiques

Ne combinez pas les déploiements progressifs avec des Canvas ou des expériences

Pour éviter que des utilisateurs soient activés et désactivés par différents points d’entrée, vous devriez soit régler le curseur de déploiement progressif sur une valeur supérieure à zéro, SOIT activer le feature flag dans un Canvas ou une expérience. Il est recommandé, si vous prévoyez d’utiliser un feature flag dans un Canvas ou une expérience, de maintenir le pourcentage de déploiement à zéro.

Conventions de nommage

Pour garder votre code clair et cohérent, envisagez d’utiliser le format suivant lorsque vous nommez l’ID de votre feature flag :

1
BEHAVIOR_PRODUCT_FEATURE

Remplacez les éléments suivants :

Voici un exemple de feature flag où show est le comportement, animation_profile est le produit, et driver est la fonctionnalité :

1
show_animation_profile_driver

Anticiper

Privilégiez toujours la prudence. Lorsque vous envisagez de nouvelles fonctionnalités qui pourraient nécessiter un mécanisme de désactivation, il vaut mieux publier du nouveau code avec un feature flag sans en avoir besoin que de réaliser qu’une nouvelle mise à jour de l’application est nécessaire.

Soyez descriptif

Ajoutez une description à votre feature flag. Bien qu’il s’agisse d’un champ facultatif dans Braze, cela peut aider à répondre aux questions que d’autres personnes pourraient se poser en parcourant les feature flags disponibles.

• Les coordonnées de la personne responsable de l’activation et du comportement de ce flag
• La date à laquelle ce flag devrait être désactivé
• Des liens vers la documentation ou des notes concernant la nouvelle fonctionnalité contrôlée par ce flag
• Les éventuelles dépendances ou notes sur l’utilisation de la fonctionnalité

Nettoyer les anciens feature flags

Nous sommes tous coupables de laisser des fonctionnalités activées à 100 % de déploiement plus longtemps que nécessaire.

Pour aider à garder votre code (et votre tableau de bord Braze) propre, supprimez les feature flags permanents de votre base de code une fois que tous les utilisateurs ont effectué la mise à jour et que vous n’avez plus besoin de la possibilité de désactiver la fonctionnalité. Cela contribue à réduire la complexité de votre environnement de développement, tout en gardant votre liste de feature flags ordonnée.