Feature-Flags erstellen

Mit Feature-Flags können Sie Funktionen für eine ausgewählte Nutzergruppe remote aktivieren oder deaktivieren. Erstellen Sie ein neues Feature-Flag im Braze-Dashboard. Geben Sie einen Namen und eine ID, eine Zielgruppe und einen Prozentsatz der Nutzer:innen an, für die dieses Feature aktiviert werden soll. Dann können Sie mit der gleichen ID im Code Ihrer App oder Website bestimmte Teile Ihrer Geschäftslogik bedingt ausführen. Mehr über Feature-Flags und wie Sie sie in Braze verwenden können, erfahren Sie unter Über Feature-Flags.

Voraussetzungen

SDK-Version

Wenn Sie Feature-Flags verwenden möchten, stellen Sie sicher, dass Ihre SDKs mit den folgenden Mindestversionen auf dem neuesten Stand sind:

Braze-Berechtigungen

Um Feature-Flags im Dashboard zu verwalten, müssen Sie entweder Administrator:in sein oder über die folgenden Berechtigungen verfügen:

Erstellen eines Feature-Flags

1. Schritt: Neues Feature-Flag erstellen

Gehen Sie zu Messaging > Feature Flags und wählen Sie dann Feature-Flag erstellen.

2. Schritt: Details angeben

Geben Sie unter Feature-Flag-Details einen Namen, eine ID und eine Beschreibung für Ihr Feature-Flag ein.

Schritt 2a: Angepasste Eigenschaften erstellen

Unter Eigenschaften können Sie optional angepasste Eigenschaften erstellen, auf die Ihre App über das Braze SDK zugreifen kann, wenn Ihr Feature aktiviert ist. Sie können jeder Variablen einen String-, Booleschen-, Bild-, Zeitstempel-, JSON- oder Zahlenwert zuweisen sowie einen Standardwert festlegen.

• beispiel

Im folgenden Beispiel zeigt das Feature-Flag ein Banner für einen nicht vorrätigen Artikel in einem E-Commerce-Shop an, wobei die aufgeführten angepassten Eigenschaften verwendet werden:

Eigenschaftsname	Typ	Wert
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 }

Tipp

Sie können beliebig viele Eigenschaften hinzufügen. Die Eigenschaften eines Feature-Flags sind jedoch auf insgesamt 10.000 Zeichen begrenzt.

4. Schritt: Segmente für die Zielgruppe auswählen

Bevor Sie ein Feature-Flag einführen, müssen Sie ein Segment von Nutzer:innen als Zielgruppe auswählen. Wählen Sie Regel hinzufügen für Ihr neu erstelltes Flag und verwenden Sie anschließend die Dropdown-Menüs für Filtergruppe und Segment, um Nutzer:innen aus Ihrer Zielgruppe herauszufiltern. Fügen Sie mehrere Filter hinzu, um Ihre Zielgruppe weiter einzugrenzen.

5. Schritt: Rollout-Traffic festlegen

Standardmäßig sind Feature-Flags immer inaktiv, wodurch Sie das Veröffentlichungsdatum Ihres Features von der vollständigen Nutzeraktivierung trennen können. Um mit der Einführung zu beginnen, geben Sie im Abschnitt Rollout-Traffic einen Prozentsatz in das Textfeld ein. Dadurch wird der Prozentsatz der zufälligen Nutzer:innen in Ihrem ausgewählten Segment bestimmt, die dieses neue Feature erhalten sollen.

Wichtig

Legen Sie den Rollout-Traffic erst dann auf einen Wert über 0 % fest, wenn Sie bereit sind, Ihr neues Feature freizuschalten. Wenn Sie Ihr Feature-Flag zunächst im Dashboard definieren, lassen Sie diese Einstellung auf 0 %.

Wichtig

Um ein Flag mit nur einer Regel oder für eine einzelne Zielgruppe einzuführen, fügen Sie Ihre erste Regel mit Segmentierungskriterien und ausgewählten Rollout-Prozentsätzen hinzu. Überprüfen Sie abschließend, ob die Regel Alle anderen deaktiviert ist, und speichern Sie Ihr Flag.

Feature-Flag-Rollouts mit mehreren Regeln

Nutzen Sie Feature-Flag-Rollouts mit mehreren Regeln, um eine Abfolge von Regeln für die Bewertung von Nutzer:innen zu definieren, die eine präzise Segmentierung und kontrollierte Feature-Veröffentlichungen ermöglicht. Diese Methode eignet sich hervorragend, um dasselbe Feature für unterschiedliche Zielgruppen bereitzustellen.

Auswertungsreihenfolge

Feature-Flag-Regeln werden von oben nach unten in der Reihenfolge ihrer Auflistung ausgewertet. Eine Nutzer:in qualifiziert sich für die erste Regel, die auf sie zutrifft. Wenn eine Nutzer:in keine der Regeln erfüllt, wird ihre Berechtigung anhand der Standardregel „Alle anderen“ bestimmt.

Nutzerqualifikation

• Wenn eine Nutzer:in die Kriterien der ersten Regel erfüllt, ist sie sofort berechtigt, das Feature-Flag zu erhalten.
• Wenn eine Nutzer:in die erste Regel nicht erfüllt, wird sie anhand der zweiten Regel bewertet, und so weiter.

Die sequenzielle Auswertung wird fortgesetzt, bis eine Nutzer:in die Kriterien einer Regel erfüllt oder die Regel „Alle anderen“ am Ende der Liste erreicht.

Regel „Alle anderen“

Die Regel „Alle anderen“ fungiert als Standard. Wenn eine Nutzer:in keine der vorangegangenen Regeln erfüllt, wird ihre Berechtigung für das Feature-Flag durch die Umschalteinstellung der Regel „Alle anderen“ bestimmt. Wenn beispielsweise die Regel „Alle anderen“ auf „Aus“ gestellt ist, erhält eine Nutzer:in, die die Kriterien für keine andere Regel erfüllt, im Standardzustand das Feature-Flag nicht zu Beginn ihrer Sitzung.

Regeln neu anordnen

Standardmäßig werden die Regeln in der Reihenfolge ihrer Erstellung angeordnet. Sie können diese Regeln jedoch neu anordnen, indem Sie sie im Dashboard per Drag-and-Drop verschieben.

Anwendungsfälle für Feature-Flags mit mehreren Regeln

Schrittweise Einführung einer Checkout-Seite

Angenommen, Sie arbeiten für eine E-Commerce-Marke und haben eine neue Checkout-Seite, die Sie in verschiedenen Regionen einführen möchten, um die Stabilität sicherzustellen. Mit Feature-Flag-Rollouts mit mehreren Regeln können Sie Folgendes festlegen:

• Regel 1: Ihr US-Segment ist auf 100 % eingestellt.
• Regel 2: Ihr Segment ist auf 50 % Ihrer brasilianischen Nutzer:innen eingestellt, sodass nicht alle gleichzeitig den Ablauf erhalten.
• Regel 3 (Alle anderen): Für alle anderen Nutzer:innen aktivieren Sie Ihre Regel „Alle anderen“ und stellen Sie sie auf 15 % ein, damit ein Teil aller Nutzer:innen den neuen Ablauf testen kann.

Interne Tester:innen zuerst erreichen

Angenommen, Sie sind Produktmanager:in und möchten sicherstellen, dass Ihre internen Tester:innen bei der Veröffentlichung eines neuen Produkts stets das Feature-Flag erhalten. Sie können Ihr internes Tester-Segment zu Ihrer ersten Regel hinzufügen und es auf 100 % festlegen, sodass Ihre internen Tester:innen bei jeder Feature-Einführung berechtigt sind.

Verwendung des Felds „aktiviert“ für Feature-Flags

Nachdem Sie Ihr Feature-Flag definiert haben, konfigurieren Sie Ihre App oder Website so, dass überprüft wird, ob es für eine bestimmte Nutzer:in aktiviert ist. Ist es aktiviert, legen Sie eine Aktion fest oder referenzieren die Variablen-Eigenschaften des Feature-Flags je nach Ihrem Anwendungsfall. Das Braze SDK stellt Getter-Methoden bereit, um den Status des Feature-Flags und seine Eigenschaften in Ihre App einzubinden.

Feature-Flags werden beim Sitzungsstart automatisch aktualisiert, sodass Sie jeweils die aktuellste Version Ihres Features anzeigen können. Das SDK speichert diese Werte im Cache, sodass sie auch offline verwendet werden können.

Hinweis

Vergewissern Sie sich, dass Sie Feature-Flag-Impressionen protokollieren.

Nehmen wir an, Sie möchten einen neuen Typ von Nutzerprofil für Ihre App einführen. Sie können die ID als expanded_user_profile festlegen. Dann würden Sie Ihre App prüfen lassen, ob sie dieses neue Nutzerprofil einer bestimmten Nutzer:in anzeigen soll. Zum Beispiel:

• 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

Protokollierung einer Feature-Flag-Impression

Tracken Sie eine Feature-Flag-Impression, wenn eine Nutzer:in die Gelegenheit hatte, mit dem neuen Feature zu interagieren, oder wenn sie bei deaktiviertem Feature hätte interagieren können (im Fall einer Kontrollgruppe in einem A/B-Test). Feature-Flag-Impressionen werden nur einmal pro Sitzung protokolliert.

Normalerweise können Sie diese Codezeile direkt unterhalb der Stelle einfügen, an der Sie das Feature-Flag in Ihrer App referenzieren:

• 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");

Zugriff auf Eigenschaften

Um auf die Eigenschaften eines Feature-Flags zuzugreifen, verwenden Sie je nach dem im Dashboard definierten Typ eine der folgenden Methoden.

Wenn für den von Ihnen angegebenen Schlüssel keine Eigenschaft des entsprechenden Typs vorhanden ist, geben diese Methoden null zurück.

• 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")

Abrufen einer Liste aller Feature-Flags

• 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

Aktualisieren von Feature-Flags

Sie können die Feature-Flags der aktuellen Nutzer:in während der Sitzung aktualisieren, um die neuesten Werte aus Braze abzurufen.

Tipp

Die Aktualisierung erfolgt automatisch beim Sitzungsstart. Eine Aktualisierung ist nur vor wichtigen Nutzeraktionen erforderlich, z. B. vor dem Laden einer Checkout-Seite, oder wenn Sie wissen, dass ein Feature-Flag referenziert werden wird.

• 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()

Auf Änderungen lauschen

Sie können das Braze SDK so konfigurieren, dass es Ihre App überwacht und aktualisiert, wenn das SDK Feature-Flags aktualisiert.

Dies ist nützlich, wenn Sie Ihre App aktualisieren möchten, falls eine Nutzer:in nicht mehr für ein Feature berechtigt ist – zum Beispiel, um einen Status in Ihrer App festzulegen, der darauf basiert, ob ein Feature aktiviert ist oder nicht, oder auf einem seiner Eigenschaftswerte.

• 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;
};

Überprüfung der Nutzerberechtigung

Um zu überprüfen, für welche Feature-Flags eine Nutzer:in in Braze berechtigt ist, gehen Sie zu Audience > Nutzer:innen suchen, suchen Sie dann nach einer Nutzer:in und wählen Sie sie aus.

Im Tab Feature-Flag-Berechtigung können Sie die Liste der berechtigten Feature-Flags nach Plattform, Anwendung oder Gerät filtern. Sie können auch eine Vorschau der Payload anzeigen, die an die Nutzer:in zurückgegeben wird, indem Sie neben einem Feature-Flag auswählen.

Anzeigen des Changelogs

Um den Changelog eines Feature-Flags anzuzeigen, öffnen Sie ein Feature-Flag und wählen Sie Changelog.

Hier können Sie nachsehen, wann eine Änderung stattgefunden hat, wer die Änderung vorgenommen hat, zu welcher Kategorie sie gehört und vieles mehr.

Segmentieren mit Feature-Flags

Braze verfolgt automatisch, welche Nutzer:innen derzeit für ein Feature-Flag aktiviert sind. Sie können ein Segment erstellen oder Messaging gezielt ausrichten, indem Sie den Filter Feature-Flag verwenden. Weitere Informationen zum Filtern nach Segmenten finden Sie unter Erstellen eines Segments.

Hinweis

Um rekursive Segmente zu vermeiden, ist es nicht möglich, ein Segment zu erstellen, das auf andere Feature-Flags verweist.

Best Practices

Kombinieren Sie Rollouts nicht mit Canvases oder Experimenten

Um zu vermeiden, dass Nutzer:innen durch unterschiedliche Einstiegspunkte aktiviert und deaktiviert werden, sollten Sie entweder den Rollout-Schieberegler auf einen Wert größer als null setzen ODER das Feature-Flag in einem Canvas oder Experiment aktivieren. Wenn Sie ein Feature-Flag in einem Canvas oder Experiment verwenden möchten, sollten Sie den Rollout-Prozentsatz als Best Practice auf null belassen.

Benennungskonventionen

Um Ihren Code übersichtlich und einheitlich zu halten, empfiehlt es sich, bei der Benennung der Feature-Flag-ID das folgende Format zu verwenden:

1
BEHAVIOR_PRODUCT_FEATURE

Ersetzen Sie Folgendes:

Hier ist ein Beispiel für ein Feature-Flag, wobei show das Verhalten, animation_profile das Produkt und driver das Feature ist:

1
show_animation_profile_driver

Vorausplanen

Gehen Sie immer auf Nummer sicher. Wenn Sie neue Features in Betracht ziehen, die möglicherweise einen Aus-Schalter erfordern, ist es besser, neuen Code mit einem Feature-Flag zu veröffentlichen und es nicht zu benötigen, als festzustellen, dass ein neues App-Update erforderlich ist.

Beschreibend sein

Fügen Sie eine Beschreibung zu Ihrem Feature-Flag hinzu. Dies ist zwar ein optionales Feld in Braze, aber es kann helfen, Fragen zu beantworten, die andere beim Durchsuchen der verfügbaren Feature-Flags haben könnten.

• Kontaktinformationen der Personen, die für die Aktivierung und das Verhalten dieses Flags verantwortlich sind
• Wann dieses Flag deaktiviert werden sollte
• Links zur Dokumentation oder zu Notizen über das neue Feature, das dieses Flag steuert
• Etwaige Abhängigkeiten oder Hinweise zur Verwendung des Features

Alte Feature-Flags bereinigen

Wir alle neigen dazu, Features länger als nötig bei einem Rollout-Prozentsatz von 100 % zu belassen.

Um Ihren Code (und das Braze-Dashboard) sauber zu halten, entfernen Sie permanente Feature-Flags aus Ihrer Codebasis, nachdem alle Nutzer:innen ein Upgrade durchgeführt haben und Sie die Option zur Deaktivierung des Features nicht mehr benötigen. Auf diese Weise lässt sich die Komplexität der Entwicklungsumgebung verringern und gleichzeitig die Liste der Feature-Flags übersichtlich halten.