Le suivi des feature flags est disponible dans le SDK Browser RUM. Pour commencer à utiliser cette fonctionnalité, configurez la surveillance Browser RUM. La version 4.25.0 ou une version ultérieure du SDK Browser RUM est requise.

Pour commencer à recueillir les données des feature flags, initialisez le SDK RUM et configurez le paramètre d’initialisation enableExperimentalFeatures avec ["feature_flags"].

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

  // Initialiser le SDK Browser Datadog
  datadogRum.init({
    ...
    enableExperimentalFeatures: ["feature_flags"],
    ...
});

window.DD_RUM.onReady(function() {
    window.DD_RUM.init({
      ...
      enableExperimentalFeatures: ["feature_flags"],
      ...
    })
})

window.DD_RUM &&
    window.DD_RUM.init({
      ...
      enableExperimentalFeatures: ["feature_flags"],
      ...
    })

Le suivi des feature flags est disponible dans le SDK iOS RUM. Pour commencer à utiliser cette fonctionnalité, configurez la surveillance iOS RUM. La version 1.16.0 ou une version ultérieure du SDK iOS RUM est requise.

Le suivi des feature flags est disponible dans le SDK Android RUM. Pour commencer à utiliser cette fonctionnalité, configurez la surveillance Android RUM. La version 1.18.0 ou une version ultérieure du SDK Android RUM est requise.

Le suivi des feature flags est disponible pour vos applications Flutter. Pour commencer à utiliser cette fonctionnalité, configurez la surveillance Flutter RUM. La version 1.3.2 ou une version ultérieure du plug-in Flutter est requise.

Le suivi des feature flags est disponible pour vos applications React Native. Pour commencer à utiliser cette fonctionnalité, configurez la surveillance React Native RUM. La version 1.7.0 ou une version ultérieure du SDK React Native RUM est requise.

Initialisez le SDK d’Amplitude et utilisez l’extrait de code suivant afin de créer un écouteur d’exposition chargé de transmettre l’évaluation des feature flags à Datadog :

Pour en savoir plus sur l’initialisation du SDK d’Amplitude, consultez la documentation relative au SDK JavaScript d’Amplitude (en anglais).

  const experiment = Experiment.initialize("CLIENT_DEPLOYMENT_KEY", {
    exposureTrackingProvider: {
      track(exposure: Exposure)  {
        // Envoyer le feature flag lorsqu'Amplitude transmet l'exposition
        datadogRum.addFeatureFlagEvaluation(exposure.flag_key, exposure.variant);
      }
    }
  })

Initialisez le SDK d’Amplitude et utilisez l’extrait de code ci-dessous afin de créer un inspecteur chargé de transmettre l’évaluation des feature flags à Datadog.

Pour en savoir plus sur l’initialisation du SDK d’Amplitude, consultez la documentation relative au SDK iOS d’Amplitude (en anglais).

  class DatadogExposureTrackingProvider : ExposureTrackingProvider {
    func track(exposure: Exposure) {
      // Envoyer le feature flag lorsqu'Amplitude transmet l'exposition
      if let variant = exposure.variant {
        RUMMonitor.shared().addFeatureFlagEvaluation(name: exposure.flagKey, value: variant)
      }
    }
  }

  // Dans l'initialisation :
  ExperimentConfig config = ExperimentConfigBuilder()
    .exposureTrackingProvider(DatadogExposureTrackingProvider(analytics))
    .build()

Initialisez le SDK d’Amplitude et utilisez l’extrait de code ci-dessous afin de créer un inspecteur chargé de transmettre l’évaluation des feature flags à Datadog.

Pour en savoir plus sur l’initialisation du SDK d’Amplitude, consultez la documentation relative au SDK Android d’Amplitude (en anglais).

  internal class DatadogExposureTrackingProvider : ExposureTrackingProvider {
    override fun track(exposure: Exposure) {
        // Envoyer le feature flag lorsqu'Amplitude transmet l'exposition
        GlobalRumMonitor.get().addFeatureFlagEvaluation(
            exposure.flagKey,
            exposure.variant.orEmpty()
        )
    }
  }

  // Dans l'initialisation :
  val config = ExperimentConfig.Builder()
      .exposureTrackingProvider(DatadogExposureTrackingProvider())
      .build()

Amplitude ne prend pas en charge cette intégration. Créez un ticket auprès d’Amplitude pour demander l’ajout de cette fonctionnalité.

Chaque fois qu’un feature flag est évalué, ajoutez la fonction suivante pour transmettre les informations sur les feature flags à RUM :

datadogRum.addFeatureFlagEvaluation(key, value);

Chaque fois qu’un feature flag est évalué, ajoutez la fonction suivante pour transmettre les informations sur les feature flags à RUM :

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

Chaque fois qu’un feature flag est évalué, ajoutez la fonction suivante pour transmettre les informations sur les feature flags à RUM :

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

Chaque fois qu’un feature flag est évalué, ajoutez la fonction suivante pour transmettre les informations sur les feature flags à RUM :

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

Chaque fois qu’un feature flag est évalué, ajoutez la fonction suivante pour transmettre les informations sur les feature flags à RUM :

DdRum.addFeatureFlagEvaluation(key, value);

Initialisez le SDK de DevCycle et abonnez-vous à l’événement variableEvaluated. Vous pouvez choisir de vous abonner à l’ensemble des évaluations de variable avec variableEvaluated:* ou de vous abonner à seulement certaines d’entre elles avec variableEvaluated:my-variable-key.

Pour en savoir plus sur l’initialisation du SDK de DevCycle, consultez la documentation relative au SDK JavaScript de DevCycle (en anglais). Pour obtenir plus d’informations sur le système d’événements DevCycle, consultez la documentation relative aux événements du SDK de DevCycle (en anglais).

const user = { user_id: "<USER_ID>" };
const dvcOptions = { ... };
const dvcClient = initialize("<CLÉ_SDK_CLIENT_DVC>", user, dvcOptions);
...
dvcClient.subscribe(
    "variableEvaluated:*",
    (key, variable) => {
        // suivre toutes les évaluations de variable
        datadogRum.addFeatureFlagEvaluation(key, variable.value);
    }
)
...
dvcClient.subscribe(
    "variableEvaluated:my-variable-key",
    (key, variable) => {
        // suivre une évaluation de variable spécifique
        datadogRum.addFeatureFlagEvaluation(key, variable.value);
    }
)

DevCycle ne prend pas en charge cette intégration. Créez un ticket auprès de DevCycle pour demander l’ajout de cette fonctionnalité.

DevCycle ne prend pas en charge cette intégration. Créez un ticket auprès de DevCycle pour demander l’ajout de cette fonctionnalité.

DevCycle ne prend pas en charge cette intégration. Créez un ticket auprès de DevCycle pour demander l’ajout de cette fonctionnalité.

DevCycle ne prend pas en charge cette intégration. Créez un ticket auprès de DevCycle pour demander l’ajout de cette fonctionnalité.

Initialisez le SDK de Flagsmith avec l’option datadogRum et utilisez l’extrait de code ci-dessous afin de transmettre l’évaluation des feature flags à Datadog.

Vous pouvez également configurer le client afin d’envoyer les traits Flagsmith à Datadog via datadogRum.setUser(). Pour en savoir plus sur l’initialisation du SDK de Flagsmith, consultez la documentation relative au SDK JavaScript de Flagsmith (en anglais).

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

Flagsmith ne prend pas en charge cette intégration. Créez un ticket auprès de Flagsmith pour demander l’ajout de cette fonctionnalité.

Flagsmith ne prend pas en charge cette intégration. Créez un ticket auprès de Flagsmith pour demander l’ajout de cette fonctionnalité.

Flagsmith ne prend pas en charge cette intégration. Créez un ticket auprès de Flagsmith pour demander l’ajout de cette fonctionnalité.

Flagsmith ne prend actuellement pas en charge cette intégration. Créez un ticket auprès de Flagsmith pour demander l’ajout de cette fonctionnalité.

Initialisez le SDK de LaunchDarkly et utilisez l’extrait de code ci-dessous afin de créer un inspecteur chargé de transmettre l’évaluation des feature flags à Datadog.

Pour en savoir plus sur l’initialisation du SDK de LaunchDarkly, consultez la documentation relative au SDK JavaScript de LaunchDarkly (en anglais).

const client = LDClient.initialize("<ID_CÔTÉ_CLIENT>", "<CONTEXTE>", {
  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 auprès de LaunchDarkly pour demander l’ajout de cette fonctionnalité.

LaunchDarkly ne prend pas en charge cette intégration. Créez un ticket auprès de LaunchDarkly pour demander l’ajout de cette fonctionnalité.

LaunchDarkly ne prend pas en charge cette intégration. Créez un ticket auprès de LaunchDarkly pour demander l’ajout de cette fonctionnalité.

LaunchDarkly ne prend actuellement pas en charge cette intégration. Créez un ticket auprès de LaunchDarkly pour demander l’ajout de cette fonctionnalité.

Initialisez le SDK de Split et utilisez l’extrait de code suivant afin de créer un écouteur d’impression chargé de transmettre l’évaluation des feature flags à Datadog :

Pour en savoir plus sur l’initialisation du SDK de Split, consultez la documentation relative au SDK JavaScript de Split (en anglais).

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

const client = factory.client();

Initialisez le SDK de Split et utilisez l’extrait de code ci-dessous afin de créer un inspecteur chargé de transmettre l’évaluation des feature flags à Datadog.

Pour en savoir plus sur l’initialisation du SDK de Split, consultez la documentation relative au SDK iOS de Split (en anglais).

  let config = SplitClientConfig()
  // Envoyer le feature flag lorsque Split transmet l'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 utilisez l’extrait de code ci-dessous afin de créer un inspecteur chargé de transmettre l’évaluation des feature flags à Datadog.

Pour en savoir plus sur l’initialisation du SDK de Split, consultez la documentation relative au SDK Android de Split (en anglais).

  internal class DatadogSplitImpressionListener : ImpressionListener {
    override fun log(impression: Impression) {
        // Envoyer le feature flag lorsque Split transmet l'impression
        GlobalRumMonitor.get().addFeatureFlagEvaluation(
            impression.split(),
            impression.treatment()
        )
    }
    override fun close() {
    }
  }

  // Dans l'initialisation :
  val apikey = BuildConfig.SPLIT_API_KEY
  val config = SplitClientConfig.builder()
      .impressionListener(DatadogSplitImpressionListener())
      .build()

Initialisez le SDK de Split et utilisez l’extrait de code ci-dessous afin de créer un inspecteur chargé de transmettre l’évaluation des feature flags à Datadog.

Pour en savoir plus sur l’initialisation du SDK de Split, consultez la documentation relative au plug-in Flutter de Split (en anglais).

  StreamSubscription<Impression> impressionsStream = _split.impressionsStream().listen((impression) {
    // Envoyer le feature flag lorsque Split transmet l'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 utilisez l’extrait de code suivant afin de créer un écouteur d’impression chargé de transmettre l’évaluation des feature flags à Datadog :

Pour en savoir plus sur l’initialisation du SDK de Split, consultez la documentation relative au SDK React Native de Split (en anglais).

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

const client = factory.client();

Le suivi des feature flags est disponible dans le SDK Browser RUM. Pour obtenir des instructions de configuration détaillées, consultez la page Débuter avec les données des features flags dans RUM.

1. Installez la version 4.25.0 ou une version ultérieure du SDK Browser RUM.

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 tel qu’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. Envoyez un e-mail à l’adresse support@statsig.com pour demander l’ajout de cette fonctionnalité.

Statsig ne prend pas en charge cette intégration. Envoyez un e-mail à l’adresse support@statsig.com pour demander l’ajout de cette fonctionnalité.

Statsig ne prend pas en charge cette intégration. Envoyez un e-mail à l’adresse support@statsig.com pour demander l’ajout de cette fonctionnalité.

Statsig ne prend actuellement pas en charge cette intégration. Envoyez un e-mail à l’adresse support@statsig.com pour demander l’ajout de cette fonctionnalité.