Indicateurs de fonctionnalité

Les indicateurs de fonctionnalité vous permettent d’activer ou de désactiver à distance des fonctionnalités pour une sélection spécifique ou aléatoire d’utilisateurs. Point essentiel : ils vous permettent d’activer et de désactiver une fonctionnalité en production sans déploiement de code supplémentaire ni mise à jour sur les boutiques d’applications. Vous pouvez ainsi déployer de nouvelles fonctionnalités en toute sécurité et en toute confiance.

Conseil

Lorsque vous êtes prêt à créer vos propres indicateurs de fonctionnalité, consultez la rubrique Créer des indicateurs de fonctionnalité.

Prérequis

Voici les versions minimum du SDK nécessaires pour commencer à utiliser les indicateurs de fonctionnalité :

Cas d’usage

Déploiements progressifs

Utilisez les indicateurs de fonctionnalité pour activer progressivement des fonctionnalités auprès d’un échantillon de population. Par exemple, vous pouvez lancer en douceur une nouvelle fonctionnalité auprès de vos utilisateurs VIP en premier. Cette stratégie permet de réduire les risques liés à la mise à disposition de nouvelles fonctionnalités à tout le monde en même temps et de détecter les bugs plus tôt.

Par exemple, imaginons que nous avons décidé d’ajouter un nouveau lien « Assistance par chat en direct » dans notre application pour un service client plus rapide. Nous pourrions publier cette fonctionnalité à tous les clients en même temps. Cependant, un déploiement à grande échelle comporte des risques, tels que :

• Notre équipe d’assistance est encore en formation, et les clients peuvent ouvrir des tickets d’assistance dès la mise en ligne. Cela ne nous laisse aucune marge si l’équipe d’assistance a besoin de plus de temps.
• Nous ne connaissons pas le volume réel de nouvelles demandes d’assistance que nous recevrons, et nous pourrions donc ne pas avoir les effectifs appropriés.
• Si notre équipe d’assistance est débordée, nous n’avons aucune stratégie pour désactiver rapidement cette fonctionnalité.
• Il pourrait y avoir des bugs dans le widget de chat, et nous ne voulons pas que les clients aient une expérience négative.

Avec les indicateurs de fonctionnalité Braze, nous pouvons au contraire déployer progressivement la fonctionnalité et atténuer tous ces risques :

• Nous activerons la fonctionnalité « Assistance par chat en direct » lorsque l’équipe d’assistance indiquera qu’elle est prête.
• Nous activerons cette nouvelle fonctionnalité pour seulement 10 % des utilisateurs afin de déterminer si nos effectifs sont suffisants.
• En cas de bugs, nous pourrons rapidement désactiver la fonctionnalité au lieu de nous précipiter pour publier une nouvelle version.

Pour déployer progressivement cette fonctionnalité, nous pouvons créer un indicateur de fonctionnalité nommé « Live Chat Widget ».

Dans le code de notre application, nous n’afficherons le bouton Start Live Chat que lorsque l’indicateur de fonctionnalité Braze est activé :

• javascript
• java
• kotlin
• swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import {useState} from "react";
import * as braze from "@braze/web-sdk";

// Get the initial value from the Braze SDK
const featureFlag = braze.getFeatureFlag("enable_live_chat");
const [liveChatEnabled, setLiveChatEnabled] = useState(featureFlag.enabled);

// - Available in version 7.0.0+
// Listen for events from the Braze SDK
braze.subscribeToFeatureFlagsEvents((event) => {
  switch (event.type) {
    case braze.ChannelEventType.CACHE_REPLAY:
    case braze.ChannelEventType.CACHE_LOAD:
    case braze.ChannelEventType.DATA_UPDATED: {
      const flag = event.cacheSnapshot.featureFlags.find((f) => f.id === "enable_live_chat");
      setLiveChatEnabled(flag ? flag.enabled : false);
      break;
    }
    case braze.ChannelEventType.ERROR:
      if (event.reason === braze.ChannelErrorReason.FEATURE_DISABLED) {
        setLiveChatEnabled(false);
      }
      break;
  }
});

// Listen for updates from the Braze SDK
braze.subscribeToFeatureFlagsUpdates(() => {
    const newValue = braze.getFeatureFlag("enable_live_chat").enabled;
    setLiveChatEnabled(newValue);
});

// Only show the Live Chat if the Braze SDK determines it is enabled
return (<>
  Need help? <button>Email Our Team</button>
  {liveChatEnabled && <button>Start Live Chat</button>}
</>)

Utilisez subscribeToFeatureFlagsEvents sur le SDK Web 7.0.0 et versions ultérieures. subscribeToFeatureFlagsUpdates est le modèle antérieur, obsolète depuis la version 7.0.0.

Pour la liste complète des événements que vous pouvez recevoir, consultez Créer des indicateurs de fonctionnalité.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// Get the initial value from the Braze SDK
FeatureFlag featureFlag = braze.getFeatureFlag("enable_live_chat");
Boolean liveChatEnabled = featureFlag != null && featureFlag.getEnabled();

// - Available in version 44.0.0+
// Listen for events from the Braze SDK
braze.subscribeToFeatureFlagsEvents(event -> {
  if (event instanceof FeatureFlagsEvent.CacheReplay || event instanceof FeatureFlagsEvent.CacheLoad || event instanceof FeatureFlagsEvent.DataUpdated) {
    FeatureFlag newFeatureFlag = braze.getFeatureFlag("enable_live_chat");
    Boolean newValue = newFeatureFlag != null && newFeatureFlag.getEnabled();
    liveChatEnabled = newValue;
  } else if (event instanceof FeatureFlagsEvent.ErrorEvent) {
    FeatureFlagsEvent.ErrorEvent errorEvent = (FeatureFlagsEvent.ErrorEvent) event;
    if (errorEvent.getReason() instanceof ChannelErrorReason.FeatureDisabled) {
      liveChatEnabled = false;
    }
  }
});

// Listen for updates from the Braze SDK
braze.subscribeToFeatureFlagsUpdates(event -> {
  FeatureFlag newFeatureFlag = braze.getFeatureFlag("enable_live_chat");
  Boolean newValue = newFeatureFlag != null && newFeatureFlag.getEnabled();
  liveChatEnabled = newValue;
});

// Only show the Live Chat view if the Braze SDK determines it is enabled
if (liveChatEnabled) {
  liveChatView.setVisibility(View.VISIBLE);
} else {
  liveChatView.setVisibility(View.GONE);
}

Utilisez subscribeToFeatureFlagsEvents sur le SDK Android 44.0.0 et versions ultérieures. subscribeToFeatureFlagsUpdates est le modèle antérieur, obsolète depuis la version 44.0.0.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// Get the initial value from the Braze SDK
val featureFlag = braze.getFeatureFlag("enable_live_chat")
var liveChatEnabled = featureFlag?.enabled

// - Available in version 44.0.0+
// Listen for events from the Braze SDK
braze.subscribeToFeatureFlagsEvents { event ->
  when (event) {
    is FeatureFlagsEvent.CacheReplay, is FeatureFlagsEvent.CacheLoad, is FeatureFlagsEvent.DataUpdated -> {
      val newValue = braze.getFeatureFlag("enable_live_chat")?.enabled
      liveChatEnabled = newValue
    }
    is FeatureFlagsEvent.ErrorEvent -> {
      if (event.reason is ChannelErrorReason.FeatureDisabled) {
        liveChatEnabled = false
      }
    }
    else -> {}
  }
}

// Listen for updates from the Braze SDK
braze.subscribeToFeatureFlagsUpdates {
  val newValue = braze.getFeatureFlag("enable_live_chat")?.enabled
  liveChatEnabled = newValue
}

// Only show the Live Chat view if the Braze SDK determines it is enabled
if (liveChatEnabled) {
  liveChatView.visibility = View.VISIBLE
} else {
  liveChatView.visibility = View.GONE
}

Utilisez subscribeToFeatureFlagsEvents sur le SDK Android 44.0.0 et versions ultérieures. subscribeToFeatureFlagsUpdates est le modèle antérieur, obsolète depuis la version 44.0.0.

Remarque

La lecture de braze.featureFlags.featureFlags ou braze.featureFlags.featureFlag(id:) bloque le thread appelant jusqu’à ce que le SDK ait terminé ses opérations post-initialisation. Pour les contextes du thread principal ou sensibles à la latence, utilisez getAllFeatureFlags(_:) à la place.

1
2
3
4
5

// Non-blocking — completion handler always delivers on the main thread.
braze.featureFlags.getAllFeatureFlags { flags in
  let liveChatEnabled = flags.first(where: { $0.id == "enable_live_chat" })?.enabled ?? false
  liveChatView.isHidden = !liveChatEnabled
}

En Objective-C :

1
2
3

[braze.featureFlags getAllFeatureFlagsWithCompletion:^(NSArray<BRZFeatureFlag *> *flags) {
  // Use `flags` here.
}];

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Get the initial value from the Braze SDK
let featureFlag = braze.featureFlags.featureFlag(id: "enable_live_chat")
var liveChatEnabled = featureFlag?.enabled ?? false

// - Available in version 19.0.0+
// Listen for events from the Braze SDK
let cancellable = braze.featureFlags.subscribeToEvents { event in
  switch event {
  case .cacheReplay, .cacheLoad, .dataUpdated:
    let newValue = braze.featureFlags.featureFlag(id: "enable_live_chat")?.enabled ?? false
    liveChatEnabled = newValue
  default:
    break
  }
}

// Listen for updates from the Braze SDK
let cancellable = braze.featureFlags.subscribeToUpdates { _ in
  let newValue = braze.featureFlags.featureFlag(id: "enable_live_chat")?.enabled ?? false
  liveChatEnabled = newValue
}

// Only show the Live Chat view if the Braze SDK determines it is enabled
liveChatView.isHidden = !liveChatEnabled

Utilisez subscribeToEvents(_:) sur le SDK Swift 19.0.0 et versions ultérieures. subscribeToUpdates(_:) est le modèle antérieur, obsolète depuis la version 19.0.0.

Pour savoir quand chaque événement se déclenche, et ce que signifient chaque raison de mise à jour, état de nouvelle tentative, action d’analyse et raison d’erreur, consultez Abonnements aux événements.

Contrôler les variables de l’application à distance

Utilisez les indicateurs de fonctionnalité pour modifier les fonctionnalités de votre application en production. Cela peut être particulièrement important pour les applications mobiles, où les validations des boutiques d’applications empêchent de déployer rapidement des modifications pour tous les utilisateurs.

Par exemple, imaginons que notre équipe marketing souhaite lister nos ventes et promotions en cours dans la navigation de notre application. Normalement, nos ingénieurs ont besoin d’un délai d’une semaine pour toute modification et de trois jours pour une validation par la boutique d’applications. Mais avec Thanksgiving, le Black Friday, le Cyber Monday, Hanouka, Noël et le Nouvel An sur une période de deux mois, nous ne serons pas en mesure de respecter ces délais serrés.

Avec les indicateurs de fonctionnalité, nous pouvons laisser Braze alimenter le contenu du lien de navigation de notre application, permettant à notre responsable marketing d’effectuer des modifications en quelques minutes plutôt qu’en plusieurs jours.

Pour configurer cette fonctionnalité à distance, nous allons créer un nouvel indicateur de fonctionnalité appelé navigation_promo_link et définir les propriétés initiales suivantes :

Dans notre application, nous utiliserons les méthodes getter de Braze pour récupérer les propriétés de cet indicateur de fonctionnalité et construire les liens de navigation en fonction de ces valeurs :

• javascript
• java
• kotlin
• swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import * as braze from "@braze/web-sdk";
import {useState} from "react";

const featureFlag = braze.getFeatureFlag("navigation_promo_link");
// Check if the feature flag is enabled
const [promoEnabled, setPromoEnabled] = useState(featureFlag.enabled);
// Read the "link" property
const [promoLink, setPromoLink] = useState(featureFlag.getStringProperty("link"));
// Read the "text" property
const [promoText, setPromoText] = useState(featureFlag.getStringProperty("text"));

return (<>
  <div>
    <a href="/">Home</a>
    { promoEnabled && <a href={promoLink}>{promoText}</a> }
    <a href="/products">Products</a>
    <a href="/categories">Categories
  </div>
</>)

1
2
3
4
5
6
7
8
9
10

// liveChatView is the View container for the Live Chat UI
FeatureFlag featureFlag = braze.getFeatureFlag("navigation_promo_link");
if (featureFlag != null && featureFlag.getEnabled()) {
  liveChatView.setVisibility(View.VISIBLE);
} else {
  liveChatView.setVisibility(View.GONE);
}
liveChatView.setPromoLink(featureFlag.getStringProperty("link"));
liveChatView.setPromoText(featureFlag.getStringProperty("text"));

1
2
3
4
5
6
7
8
9

// liveChatView is the View container for the Live Chat UI
val featureFlag = braze.getFeatureFlag("navigation_promo_link")
if (featureFlag?.enabled == true) {
  liveChatView.visibility = View.VISIBLE
} else {
  liveChatView.visibility = View.GONE
}
liveChatView.promoLink = featureFlag?.getStringProperty("link")
liveChatView.promoText = featureFlag?.getStringProperty("text")

1
2
3
4
5
6
7
8

let featureFlag = braze.featureFlags.featureFlag(id: "navigation_promo_link")
if let featureFlag {
  liveChatView.isHidden = !featureFlag.enabled
} else {
  liveChatView.isHidden = true
}
liveChatView.promoLink = featureFlag?.stringProperty("link")
liveChatView.promoText = featureFlag?.stringProperty("text")

Désormais, la veille de Thanksgiving, nous n’avons plus qu’à modifier ces valeurs de propriétés dans le tableau de bord de Braze.

Ainsi, la prochaine fois que quelqu’un charge l’application, il verra les nouvelles offres de Thanksgiving.

Coordination des messages

Utilisez les indicateurs de fonctionnalité pour synchroniser le déploiement d’une fonctionnalité et les communications, et renforcer la collaboration entre les équipes produit et marketing. En coordonnant les sorties de fonctionnalités et les communications via les indicateurs de fonctionnalité, les deux équipes peuvent aligner leurs stratégies et créer des expériences utilisateur cohérentes.

Par exemple, imaginons que nous lançons un nouveau programme de fidélité et de récompenses pour nos utilisateurs. Il peut être difficile pour les équipes marketing et produit de coordonner parfaitement le timing des messages promotionnels avec le déploiement d’une fonctionnalité. Cependant, avec les indicateurs de fonctionnalité dans Canvas, notre équipe produit peut appliquer une logique sophistiquée pour activer une fonctionnalité pour une audience spécifique, tandis que notre équipe marketing gère les messages associés destinés à ces mêmes utilisateurs.

Pour coordonner efficacement le déploiement de la fonctionnalité et les communications, nous allons créer un nouvel indicateur de fonctionnalité appelé show_loyalty_program. Pour notre déploiement initial par phases, nous laisserons Canvas contrôler quand et pour qui l’indicateur de fonctionnalité est activé. Pour l’instant, nous laisserons le pourcentage de déploiement à 0 % et ne sélectionnerons aucun Segment cible.

Ensuite, dans Canvas, nous allons créer une étape Indicateur de fonctionnalité qui active l’indicateur de fonctionnalité show_loyalty_program pour notre Segment « Clients à haute valeur » :

Désormais, les utilisateurs de ce Segment commencent à voir le nouveau programme de fidélité, et une fois celui-ci activé, un e-mail et une enquête sont envoyés automatiquement pour aider nos équipes à recueillir des retours.

Expérimentation de fonctionnalités

Utilisez les indicateurs de fonctionnalité pour expérimenter et confirmer vos hypothèses sur votre nouvelle fonctionnalité. En répartissant le trafic en deux groupes ou plus, vous pouvez comparer l’impact d’un indicateur de fonctionnalité entre les groupes et déterminer la meilleure marche à suivre en fonction des résultats.

Pour les expériences avec les indicateurs de fonctionnalité, vous pouvez avoir jusqu’à neuf groupes au total : un groupe de contrôle et jusqu’à huit variantes.

Un test A/B est un outil puissant qui compare les réponses des utilisateurs à plusieurs versions d’une variable.

Dans cet exemple, notre équipe a développé un nouveau flux de paiement pour notre application d’e-commerce. Même si nous sommes convaincus qu’il améliore l’expérience utilisateur, nous souhaitons effectuer un test A/B pour mesurer son impact sur le chiffre d’affaires de notre application.

Pour commencer, nous allons créer un nouvel indicateur de fonctionnalité appelé enable_checkout_v2. Nous n’ajouterons ni audience ni pourcentage de déploiement. Au lieu de cela, nous utiliserons une expérience d’indicateur de fonctionnalité pour répartir le trafic, activer la fonctionnalité et mesurer le résultat.

Dans notre application, nous vérifierons si l’indicateur de fonctionnalité est activé ou non et basculerons le flux de paiement en fonction de la réponse :

• javascript
• java
• kotlin
• swift

1
2
3
4
5
6
7
8
9

import * as braze from "@braze/web-sdk";

const featureFlag = braze.getFeatureFlag("enable_checkout_v2");
braze.logFeatureFlagImpression("enable_checkout_v2");
if (featureFlag?.enabled) {
  return <NewCheckoutFlow />
} else {
  return <OldCheckoutFlow />
}

1
2
3
4
5
6
7

FeatureFlag featureFlag = braze.getFeatureFlag("enable_checkout_v2");
braze.logFeatureFlagImpression("enable_checkout_v2");
if (featureFlag != null && featureFlag.getEnabled()) {
  return new NewCheckoutFlow();
} else {
  return new OldCheckoutFlow();
}

1
2
3
4
5
6
7

val featureFlag = braze.getFeatureFlag("enable_checkout_v2")
braze.logFeatureFlagImpression("enable_checkout_v2")
if (featureFlag?.enabled == true) {
  return NewCheckoutFlow()
} else {
  return OldCheckoutFlow()
}

1
2
3
4
5
6
7

let featureFlag = braze.featureFlags.featureFlag(id: "enable_checkout_v2")
braze.featureFlags.logFeatureFlagImpression(id: "enable_checkout_v2")
if let featureFlag, featureFlag.enabled {
  return NewCheckoutFlow()
} else {
  return OldCheckoutFlow()
}

Nous configurerons notre test A/B dans une expérience d’indicateur de fonctionnalité.

Désormais, 50 % des utilisateurs verront l’ancienne expérience, tandis que les 50 % restants verront la nouvelle. Nous pourrons ensuite analyser les deux variantes pour déterminer quel flux de paiement a entraîné un taux de conversion plus élevé.

Le taux de conversion est le pourcentage de fois où un événement défini s’est produit par rapport à l’ensemble des destinataires d’un message. Cet événement défini est déterminé lors de la création de la Campaign.

Une fois le gagnant déterminé, nous pourrons arrêter cette Campaign et augmenter le pourcentage de déploiement de l’indicateur de fonctionnalité à 100 % pour tous les utilisateurs, pendant que notre équipe d’ingénierie intégrera ce changement en dur dans la prochaine version de notre application.

Segmentation

Utilisez le filtre Indicateur de fonctionnalité pour créer un Segment ou cibler des messages vers des utilisateurs en fonction de l’activation ou non d’un indicateur de fonctionnalité. Par exemple, imaginons que vous ayez un indicateur de fonctionnalité qui contrôle le contenu premium dans votre application. Vous pourriez créer un Segment qui filtre les utilisateurs pour lesquels l’indicateur de fonctionnalité n’est pas activé, puis envoyer à ce Segment un message les encourageant à mettre à niveau leur compte pour accéder au contenu premium.

1. Ouvrez votre Segment ou l’audience de votre message.
2. Ajoutez le filtre Indicateur de fonctionnalité.
3. Sélectionnez l’indicateur de fonctionnalité.
4. Définissez le comparateur sur est pour inclure les utilisateurs pour lesquels l’indicateur de fonctionnalité est activé, ou n’est pas pour inclure les utilisateurs pour lesquels il ne l’est pas.

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 qui fait référence à d’autres indicateurs de fonctionnalité.

Limites du plan

Voici les limites des indicateurs de fonctionnalité pour les plans gratuits et payants.

Un indicateur de fonctionnalité est considéré comme actif et sera comptabilisé dans votre limite si l’une des conditions suivantes s’applique :

• Le déploiement est supérieur à 0 %
• Utilisé dans un Canvas actif
• Utilisé dans une expérience active

Même si le même indicateur de fonctionnalité remplit plusieurs critères, par exemple s’il est utilisé dans un Canvas et que le déploiement est à 50 %, il ne sera comptabilisé qu’une seule fois comme 1 indicateur de fonctionnalité actif dans votre limite.

Remarque

Pour acheter la version payante des indicateurs de fonctionnalité, contactez votre gestionnaire de compte Braze, ou demandez une mise à niveau dans le tableau de bord de Braze.