Configurer le suivi des flags de fonctionnalité

Les données des flags de fonctionnalité offrent une meilleure visibilité sur l’expérience utilisateur et le suivi des performances. Cela vous permet de déterminer quels utilisateurs se voient présenter une fonctionnalité spécifique et d’évaluer si des changements introduits impactent l’expérience utilisateur ou affectent négativement les performances.

En enrichissant vos données RUM avec des données de flags de fonctionnalité, vous pouvez être sûr que votre fonctionnalité est lancée avec succès sans causer involontairement un bug ou une régression de performance. Avec cette couche supplémentaire d’informations, vous pouvez corréler les versions de fonctionnalités avec les performances, identifier les problèmes liés à des versions spécifiques et résoudre les problèmes plus rapidement.

Configurer la surveillance RUM

Le suivi des flags de fonctionnalité est disponible dans le RUM Browser SDK, iOS, Android, Flutter et React Native.

    Pour activer la collecte de données des drapeaux de fonctionnalités pour le SDK navigateur :

    1. Configurez la surveillance RUM pour navigateur. Vous avez besoin de la version >= 4.25.0 du SDK RUM pour navigateur.

    2. Initialisez le SDK RUM et configurez le paramètre d’initialisation enableExperimentalFeatures avec ["feature_flags"].

      npm
        import { datadogRum } from '@datadog/browser-rum';

  // Initialize Datadog Browser SDK
  datadogRum.init({
    ...
    enableExperimentalFeatures: ["feature_flags"],
    ...
});
      CDN asynchrone
      window.DD_RUM.onReady(function() {
    window.DD_RUM.init({
      ...
      enableExperimentalFeatures: ["feature_flags"],
      ...
    })
})
      CDN synchrone
      window.DD_RUM &&
    window.DD_RUM.init({
      ...
      enableExperimentalFeatures: ["feature_flags"],
      ...
    })

    Pour activer la collecte de données des drapeaux de fonctionnalités pour votre application iOS :

    1. Configurez la surveillance RUM iOS. Vous avez besoin de la version >= 1.16.0 du SDK RUM iOS.

    Pour activer la collecte de données des drapeaux de fonctionnalités pour votre application Android :

    1. Configurez la surveillance RUM Android. Vous avez besoin de la version >= 1.18.0 du SDK RUM Android.

    Pour activer la collecte de données des drapeaux de fonctionnalités pour votre application Flutter :

    1. Configurez la surveillance RUM Flutter. Vous avez besoin de la version >= 1.3.2 du plugin Flutter.

    Pour activer la collecte de données des drapeaux de fonctionnalités pour votre application React Native :

    1. Configurez la surveillance RUM React Native. Vous avez besoin de la version >= 1.7.0 du SDK RUM React Native.

    Configurez une intégration de flag de fonctionnalité

    Vous pouvez commencer à collecter des données de flags de fonctionnalité avec des solutions de gestion de flags de fonctionnalité personnalisées, ou en utilisant l’un des partenaires d’intégration de Datadog énumérés ci-dessous.

    Remarque : Les caractères spéciaux suivants ne sont pas pris en charge pour le suivi des drapeaux de fonctionnalités : ., :, +, -, =, &&, ||, >, <, !, (, ), {, }, [, ], ^, ", “, ”, ~, *, ?, \. Datadog recommande d’éviter ces caractères dans la mesure du possible dans les noms de fanions de fonctionnalité. Si vous devez utiliser l’un de ces caractères, remplacez le caractère avant d’envoyer les données à Datadog. Par exemple :

    datadogRum.addFeatureFlagEvaluation(key.replaceAll(':', '_'), value);
    datadog
    amplitude
    custom
    custom
    devcycle
    eppo
    flagsmith
    growthbook
    kameleoon
    launchdarkly
    split
    statsig

    Intégration Amplitude

    Avant d’initialiser cette intégration de flag de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

      Initialisez le SDK d’Amplitude et créez un écouteur d’exposition signalant les évaluations de drapeaux de fonctionnalités à Datadog en utilisant le code suivant :

      Pour plus d’informations sur l’initialisation du SDK d’Amplitude, consultez la documentation du SDK JavaScript d’Amplitude.

        const experiment = Experiment.initialize("CLIENT_DEPLOYMENT_KEY", {
    exposureTrackingProvider: {
      track(exposure: Exposure)  {
        // Send the feature flag when Amplitude reports the exposure
        datadogRum.addFeatureFlagEvaluation(exposure.flag_key, exposure.variant);
      }
    }
  })

      Initialisez le SDK d’Amplitude et créez un inspecteur signalant les évaluations de drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

      Pour plus d’informations sur l’initialisation du SDK d’Amplitude, consultez la documentation du SDK iOS d’Amplitude.

        class DatadogExposureTrackingProvider : ExposureTrackingProvider {
    func track(exposure: Exposure) {
      // Send the feature flag when Amplitude reports the exposure
      if let variant = exposure.variant {
        RUMMonitor.shared().addFeatureFlagEvaluation(name: exposure.flagKey, value: variant)
      }
    }
  }

  // In initialization:
  ExperimentConfig config = ExperimentConfigBuilder()
    .exposureTrackingProvider(DatadogExposureTrackingProvider(analytics))
    .build()

      Initialisez le SDK d’Amplitude et créez un inspecteur signalant les évaluations de drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

      Pour plus d’informations sur l’initialisation du SDK d’Amplitude, consultez la documentation du SDK Android d’Amplitude.

      internal class DatadogExposureTrackingProvider : ExposureTrackingProvider {
  override fun track(exposure: Exposure) {
      // Send the feature flag when Amplitude reports the exposure
      GlobalRumMonitor.get().addFeatureFlagEvaluation(
          exposure.flagKey,
          exposure.variant.orEmpty()
      )
  }
}

// In initialization:
val config = ExperimentConfig.Builder()
    .exposureTrackingProvider(DatadogExposureTrackingProvider())
    .build()

      Amplitude ne prend pas en charge cette intégration. Créez un ticket avec Amplitude pour demander cette fonctionnalité.

      Intégration ConfigCat

      Avant d’initialiser cette intégration de flag de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

        Lors de l’initialisation du SDK Javascript de ConfigCat, abonnez-vous à l’événement flagEvaluated et signalez les évaluations de drapeaux de fonctionnalités à Datadog :

        const configCatClient = configcat.getClient(
  '#YOUR-SDK-KEY#',
  configcat.PollingMode.AutoPoll,
  {
    setupHooks: (hooks) =>
      hooks.on('flagEvaluated', (details) => {
        datadogRum.addFeatureFlagEvaluation(details.key, details.value);
      })
  }
);

        Pour plus d’informations sur l’initialisation du SDK Javascript de ConfigCat, consultez la documentation du SDK JavaScript de ConfigCat.

        Lors de l’initialisation du SDK Swift iOS de ConfigCat, abonnez-vous à l’événement flagEvaluated et signalez les évaluations de drapeaux de fonctionnalités à Datadog :

          let client = ConfigCatClient.get(sdkKey: "#YOUR-SDK-KEY#") { options in
    options.hooks.addOnFlagEvaluated { details in
        RUMMonitor.shared().addFeatureFlagEvaluation(featureFlag: details.key, variation: details.value)
    }
  }

        Pour plus d’informations sur l’initialisation du SDK Swift (iOS) de ConfigCat, consultez la documentation du SDK Swift iOS de ConfigCat.

        Lors de l’initialisation du SDK Android de ConfigCat, abonnez-vous à l’événement flagEvaluated et signalez les évaluations de drapeaux de fonctionnalités à Datadog :

        ConfigCatClient client = ConfigCatClient.get("#YOUR-SDK-KEY#", options -> {
  options.hooks().addOnFlagEvaluated(details -> {
      GlobalRumMonitor.get().addFeatureFlagEvaluation(details.key, details.value);
  });
});

        Pour plus d’informations sur l’initialisation du SDK Android de ConfigCat, consultez la documentation du SDK Android de ConfigCat.

        Lors de l’initialisation du SDK Dart de ConfigCat, abonnez-vous à l’événement flagEvaluated et signalez les évaluations de drapeaux de fonctionnalités à Datadog :

          final client = ConfigCatClient.get(
    sdkKey: '#YOUR-SDK-KEY#',
    options: ConfigCatOptions(
        pollingMode: PollingMode.autoPoll(),
        hooks: Hooks(
            onFlagEvaluated: (details) => {
              DatadogSdk.instance.rum?.addFeatureFlagEvaluation(details.key, details.value);
            }
        )
    )
  );

        Pour plus d’informations sur l’initialisation du SDK ConfigCat Dart (Flutter), consultez la documentation du SDK Dart de ConfigCat.

        Lors de l’initialisation du SDK ConfigCat React, abonnez-vous à l’événement flagEvaluated et signalez les évaluations des drapeaux de fonctionnalités à Datadog :

        <ConfigCatProvider
  sdkKey="YOUR_SDK_KEY"
  pollingMode={PollingMode.AutoPoll}
  options={{
    setupHooks: (hooks) =>
      hooks.on('flagEvaluated', (details) => {
        DdRum.addFeatureFlagEvaluation(details.key, details.value);
      }),
  }}
>
  ...
</ConfigCatProvider>

        Pour plus d’informations sur l’initialisation du SDK ConfigCat React, consultez la documentation du SDK React de ConfigCat.

        Gestion personnalisée des drapeaux de fonctionnalités

        Avant d’initialiser une intégration personnalisée de flag de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

          Chaque fois qu’un drapeau de fonctionnalité est évalué, ajoutez la fonction suivante pour envoyer les informations sur le drapeau de fonctionnalité à RUM :

          datadogRum.addFeatureFlagEvaluation(key, value);

          Chaque fois qu’un drapeau de fonctionnalité est évalué, ajoutez la fonction suivante pour envoyer les informations sur le drapeau de fonctionnalité à RUM :

          RUMMonitor.shared().addFeatureFlagEvaluation(key, value);

          Chaque fois qu’un drapeau de fonctionnalité est évalué, ajoutez la fonction suivante pour envoyer les informations sur le drapeau de fonctionnalité à RUM :

          GlobalRumMonitor.get().addFeatureFlagEvaluation(key, value);

          Chaque fois qu’un drapeau de fonctionnalité est évalué, ajoutez la fonction suivante pour envoyer les informations sur le drapeau de fonctionnalité à RUM :

          DatadogSdk.instance.rum?.addFeatureFlagEvaluation(key, value);

          Chaque fois qu’un drapeau de fonctionnalité est évalué, ajoutez la fonction suivante pour envoyer les informations sur le drapeau de fonctionnalité à RUM :

          DdRum.addFeatureFlagEvaluation(key, value);

          Intégration DevCycle

          Avant d’initialiser cette intégration de flag de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

            Initialisez le SDK de DevCycle et abonnez-vous à l’événement variableEvaluated, en choisissant de vous abonner à toutes les évaluations de variables variableEvaluated:* ou à des évaluations de variables particulières variableEvaluated:my-variable-key.

            Pour plus d’informations sur l’initialisation du SDK de DevCycle, consultez la documentation du SDK JavaScript de DevCycle et pour plus d’informations sur le système d’événements de DevCycle, consultez la documentation des événements du SDK de DevCycle.

            const user = { user_id: "<USER_ID>" };
const dvcOptions = { ... };
const dvcClient = initialize("<DVC_CLIENT_SDK_KEY>", user, dvcOptions);
...
dvcClient.subscribe(
    "variableEvaluated:*",
    (key, variable) => {
        // track all variable evaluations
        datadogRum.addFeatureFlagEvaluation(key, variable.value);
    }
)
...
dvcClient.subscribe(
    "variableEvaluated:my-variable-key",
    (key, variable) => {
        // track a particular variable evaluation
        datadogRum.addFeatureFlagEvaluation(key, variable.value);
    }
)

            DevCycle ne prend pas en charge cette intégration. Créez un ticket avec DevCycle pour demander cette fonctionnalité.

            DevCycle ne prend pas en charge cette intégration. Créez un ticket avec DevCycle pour demander cette fonctionnalité.

            DevCycle ne prend pas en charge cette intégration. Créez un ticket avec DevCycle pour demander cette fonctionnalité.

            DevCycle ne prend pas en charge cette intégration. Créez un ticket avec DevCycle pour demander cette fonctionnalité.

            Intégration Eppo

            Avant d’initialiser cette intégration de flag de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

              Initialisez le SDK d’Eppo et créez un journaliseur d’attribution qui signale également les évaluations des flags de fonctionnalité à Datadog en utilisant le code ci-dessous.

              Pour plus d’informations sur l’initialisation du SDK d’Eppo, consultez la documentation du SDK JavaScript d’Eppo.

              const assignmentLogger: IAssignmentLogger = {
  logAssignment(assignment) {
    datadogRum.addFeatureFlagEvaluation(assignment.featureFlag, assignment.variation);
  },
};

await eppoInit({
  apiKey: "<API_KEY>",
  assignmentLogger,
});

              Initialisez le SDK d’Eppo et créez un journaliseur d’attribution qui signale également les évaluations des flags de fonctionnalité à Datadog en utilisant le code ci-dessous.

              Pour plus d’informations sur l’initialisation du SDK d’Eppo, consultez la documentation du SDK iOS d’Eppo.

              func IAssignmentLogger(assignment: Assignment) {
  RUMMonitor.shared().addFeatureFlagEvaluation(featureFlag: assignment.featureFlag, variation: assignment.variation)
}

let eppoClient = EppoClient(apiKey: "mock-api-key", assignmentLogger: IAssignmentLogger)

              Initialisez le SDK d’Eppo et créez un journaliseur d’attribution qui signale également les évaluations des flags de fonctionnalité à Datadog en utilisant le code ci-dessous.

              Pour plus d’informations sur l’initialisation du SDK d’Eppo, consultez la documentation du SDK Android d’Eppo.

              AssignmentLogger logger = new AssignmentLogger() {
    @Override
    public void logAssignment(Assignment assignment) {
      GlobalRumMonitor.get().addFeatureFlagEvaluation(assignment.getFeatureFlag(), assignment.getVariation());
    }
};

EppoClient eppoClient = new EppoClient.Builder()
    .apiKey("YOUR_API_KEY")
    .assignmentLogger(logger)
    .application(application)
    .buildAndInit();

              Eppo ne prend pas en charge cette intégration. Contactez Eppo pour demander cette fonctionnalité.

              Initialisez le SDK d’Eppo et créez un journaliseur d’attribution qui signale également les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

              Pour plus d’informations sur l’initialisation du SDK d’Eppo, consultez la documentation du SDK React Native d’Eppo.

              const assignmentLogger: IAssignmentLogger = {
  logAssignment(assignment) {
    DdRum.addFeatureFlagEvaluation(assignment.featureFlag, assignment.variation);
  },
};

await eppoInit({
  apiKey: "<API_KEY>",
  assignmentLogger,
});

              Intégration Flagsmith

              Avant d’initialiser cette intégration de drapeau de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

                Initialisez le SDK de Flagsmith avec l’option datadogRum, qui rapporte les évaluations des drapeaux de fonctionnalité à Datadog en utilisant le code ci-dessous.

                En option, vous pouvez configurer le client afin que les traits de Flagsmith soient envoyés à Datadog via datadogRum.setUser(). Pour plus d’informations sur l’initialisation du SDK de Flagsmith, consultez la documentation du SDK JavaScript de Flagsmith.

                 // Initialize the Flagsmith SDK
 flagsmith.init({
     datadogRum: {
         client: datadogRum,
         trackTraits: true,
     },
     ...
 })

                Flagsmith ne prend pas en charge cette intégration. Créez un ticket avec Flagsmith pour demander cette fonctionnalité.

                Flagsmith ne prend pas en charge cette intégration. Créez un ticket avec Flagsmith pour demander cette fonctionnalité.

                Flagsmith ne prend pas en charge cette intégration. Créez un ticket avec Flagsmith pour demander cette fonctionnalité.

                Flagsmith ne prend actuellement pas en charge cette intégration. Créez un ticket avec Flagsmith pour demander cette fonctionnalité.

                Intégration GrowthBook

                  Lors de l’initialisation du SDK de GrowthBook, rapportez les évaluations des drapeaux de fonctionnalité à Datadog en utilisant le rappel onFeatureUsage.

                  Pour plus d’informations sur l’initialisation du SDK de GrowthBook, consultez la documentation du SDK JavaScript de GrowthBook.

                  const gb = new GrowthBook({
  ...,
  onFeatureUsage: (featureKey, result) => {
    datadogRum.addFeatureFlagEvaluation(featureKey, result.value);
  },
});

gb.init();

                  GrowthBook ne prend pas en charge cette intégration. Contactez GrowthBook pour demander cette fonctionnalité.

                  Lors de l’initialisation du SDK de GrowthBook, rapportez les évaluations des drapeaux de fonctionnalité à Datadog en appelant setFeatureUsageCallback.

                  Pour plus d’informations sur l’initialisation du SDK de GrowthBook, consultez la documentation du SDK Android de GrowthBook.

                  val gbBuilder = GBSDKBuilder(...)

gbBuilder.setFeatureUsageCallback { featureKey, result ->
  GlobalRumMonitor.get().addFeatureFlagEvaluation(featureKey, result.value);
}

val gb = gbBuilder.initialize()

                  Lors de l’initialisation du SDK de GrowthBook, rapportez les évaluations des drapeaux de fonctionnalité à Datadog en appelant setFeatureUsageCallback.

                  Pour plus d’informations sur l’initialisation du SDK de GrowthBook, consultez la documentation du SDK Flutter de GrowthBook.

                  final gbBuilder = GBSDKBuilderApp(...);
gbBuilder.setFeatureUsageCallback((featureKey, result) {
  DatadogSdk.instance.rum?.addFeatureFlagEvaluation(featureKey, result.value);
});
final gb = await gbBuilder.initialize();

                  Lors de l’initialisation du SDK de GrowthBook, rapportez les évaluations des drapeaux de fonctionnalité à Datadog en utilisant le rappel onFeatureUsage.

                  Pour plus d’informations sur l’initialisation du SDK de GrowthBook, consultez la documentation du SDK React Native de GrowthBook.

                  const gb = new GrowthBook({
  ...,
  onFeatureUsage: (featureKey, result) => {
    datadogRum.addFeatureFlagEvaluation(featureKey, result.value);
  },
});

gb.init();

                  Intégration Kameleoon

                  Avant d’initialiser cette intégration de drapeau de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

                    Après avoir créé et initialisé le SDK de Kameleoon, abonnez-vous à l’événement Evaluation en utilisant le gestionnaire onEvent.

                    Pour plus d’informations sur le SDK, consultez la documentation du SDK JavaScript de Kameleoon.

                    client.onEvent(EventType.Evaluation, ({ featureKey, variation }) => {
  datadogRum.addFeatureFlagEvaluation(featureKey, variation.key);
});

                    Kameleoon ne prend pas en charge cette intégration. Contactez product@kameleoon.com pour demander cette fonctionnalité.

                    Kameleoon ne prend pas en charge cette intégration. Contactez product@kameleoon.com pour demander cette fonctionnalité.

                    Kameleoon ne prend pas en charge cette intégration. Contactez product@kameleoon.com pour demander cette fonctionnalité.

                    Après avoir créé et initialisé le SDK de Kameleoon, abonnez-vous à l’événement Evaluation en utilisant le gestionnaire onEvent.

                    En savoir plus sur l’initialisation du SDK, consultez la documentation du SDK React Native de Kameleoon.

                    const { onEvent } = useInitialize();

onEvent(EventType.Evaluation, ({ featureKey, variation }) => {
  datadogRum.addFeatureFlagEvaluation(featureKey, variation.key);
});

                    Intégration LaunchDarkly

                    Avant d’initialiser cette intégration de drapeau de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

                      Initialisez le SDK de LaunchDarkly et créez un inspecteur qui rapporte les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

                      Pour plus d’informations sur l’initialisation du SDK de LaunchDarkly, consultez la documentation du SDK JavaScript de LaunchDarkly.

                      const client = LDClient.initialize("<CLIENT_SIDE_ID>", "<CONTEXT>", {
  inspectors: [
    {
      type: "flag-used",
      name: "dd-inspector",
      method: (key: string, detail: LDClient.LDEvaluationDetail) => {
        datadogRum.addFeatureFlagEvaluation(key, detail.value);
      },
    },
  ],
});

                      LaunchDarkly ne prend pas en charge cette intégration. Créez un ticket avec LaunchDarkly pour demander cette fonctionnalité.

                      LaunchDarkly ne prend pas en charge cette intégration. Créez un ticket avec LaunchDarkly pour demander cette fonctionnalité.

                      LaunchDarkly ne prend pas en charge cette intégration. Créez un ticket avec LaunchDarkly pour demander cette fonctionnalité.

                      LaunchDarkly ne prend actuellement pas en charge cette intégration. Créez un ticket avec LaunchDarkly pour demander cette fonctionnalité.

                      Intégration Split

                      Avant d’initialiser cette intégration de drapeau de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

                        Initialisez le SDK de Split et créez un écouteur d’impression rapportant les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code suivant :

                        Pour plus d’informations sur l’initialisation du SDK de Split, consultez la documentation du SDK JavaScript de Split.

                        const factory = SplitFactory({
    core: {
      authorizationKey: "<APP_KEY>",
      key: "<USER_ID>",
    },
    impressionListener: {
      logImpression(impressionData) {
          datadogRum
              .addFeatureFlagEvaluation(
                  impressionData.impression.feature,
                  impressionData.impression.treatment
              );
    },
  },
});

const client = factory.client();

                        Initialisez le SDK de Split et créez un inspecteur qui rapporte les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

                        Pour plus d’informations sur l’initialisation du SDK de Split, consultez la documentation du SDK iOS de Split.

                          let config = SplitClientConfig()
  // Send the feature flag when Split reports the impression
  config.impressionListener = { impression in
      if let feature = impression.feature,
          let treatment = impression.treatment {
          RUMMonitor.shared().addFeatureFlagEvaluation(name: feature, value: treatment)
      }
  }

                        Initialisez le SDK de Split et créez un inspecteur qui rapporte les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

                        Pour plus d’informations sur l’initialisation du SDK de Split, consultez la documentation du SDK Android de Split.

                        internal class DatadogSplitImpressionListener : ImpressionListener {
  override fun log(impression: Impression) {
      // Send the feature flag when Split reports the impression
      GlobalRumMonitor.get().addFeatureFlagEvaluation(
          impression.split(),
          impression.treatment()
      )
  }
  override fun close() {
  }
}

// In initialization:
val apikey = BuildConfig.SPLIT_API_KEY
val config = SplitClientConfig.builder()
    .impressionListener(DatadogSplitImpressionListener())
    .build()

                        Initialisez le SDK de Split et créez un inspecteur qui rapporte les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code ci-dessous.

                        Pour plus d’informations sur l’initialisation du SDK de Split, consultez la documentation du plugin Flutter de Split.

                          StreamSubscription<Impression> impressionsStream = _split.impressionsStream().listen((impression) {
    // Send the feature flag when Split reports the impression
    final split = impression.split;
    final treatment = impression.treatment;
    if (split != null && treatment != null) {
      DatadogSdk.instance.rum?.addFeatureFlagEvaluation(split, treatment);
    }
  });

                        Initialisez le SDK de Split et créez un écouteur d’impression rapportant les évaluations des drapeaux de fonctionnalités à Datadog en utilisant le code suivant :

                        Pour plus d’informations sur l’initialisation du SDK de Split, consultez la documentation du SDK React Native de Split.

                        const factory = SplitFactory({
    core: {
      authorizationKey: "<APP_KEY>",
      key: "<USER_ID>",
    },
    impressionListener: {
      logImpression(impressionData) {
          DdRum
              .addFeatureFlagEvaluation(
                  impressionData.impression.feature,
                  impressionData.impression.treatment
              );
    },
  },
});

const client = factory.client();

                        Intégration Statsig

                        Avant d’initialiser cette intégration de drapeau de fonctionnalité, assurez-vous d’avoir configuré la surveillance RUM.

                          Initialisez le SDK de Statsig avec statsig.initialize.

                          1. Mettez à jour votre SDK RUM navigateur en version 4.25.0 ou supérieure.

                          2. Initialisez le SDK RUM et configurez le paramètre d’initialisation enableExperimentalFeatures avec ["feature_flags"].

                          3. Initialisez le SDK de Statsig (>= v4.34.0) et implémentez l’option gateEvaluationCallback comme indiqué ci-dessous :

                             await statsig.initialize('client-<STATSIG CLIENT KEY>',
 {userID: '<USER ID>'},
 {
     gateEvaluationCallback: (key, value) => {
         datadogRum.addFeatureFlagEvaluation(key, value);
     }
 }
 );

                          Statsig ne prend pas en charge cette intégration. Contactez support@statsig.com pour demander cette fonctionnalité.

                          Statsig ne prend pas en charge cette intégration. Contactez support@statsig.com pour demander cette fonctionnalité.

                          Statsig ne prend pas en charge cette intégration. Contactez support@statsig.com pour demander cette fonctionnalité.

                          Statsig ne prend actuellement pas en charge cette intégration. Contactez support@statsig.com pour demander cette fonctionnalité.

                          Prochaines étapes

                          Voir et analyser vos drapeaux de fonctionnalités.

                          Lectures complémentaires

                          Documentation, liens et articles supplémentaires utiles:

                          Découvrez l'explorateur RUMDOCUMENTATION more more Assurez la sécurité des versions avec le suivi des flags de fonctionnalité dans Datadog RUMBLOG more more