Configurar Feature Flag Tracking

Documentos > RUM y Session Replay > Seguimiento de indicadores de características > Configurar Feature Flag Tracking

Los datos de los indicadores de características proporcionan una mayor visibilidad de la experiencia del usuario y la monitorización del rendimiento. Permite determinar a qué usuarios se está mostrando una característica específica y evaluar si los cambios introducidos están repercutiendo en la experiencia del usuario o afectando el rendimiento.

Al mejorar tus datos RUM con datos de indicadores de características, puedes estar seguro de que tu función se lanza correctamente sin causar involuntariamente un error o una regresión del rendimiento. Con esta capa adicional de información, puedes correlacionar los lanzamientos de funciones con el rendimiento, identificar los problemas con lanzamientos específicos y solucionar los problemas más rápidamente.

Configurar la monitorización de RUM

El seguimiento de los indicadores de características está disponible en los SDK de RUM Browser, iOS, Android, Flutter y React Native.

Para activar la recopilación de datos de los indicadores de características para el SDK del navegador:

Configura Monitorización del navegador de RUM. Necesitas la versión >= 4.25.0 del SDK de RUM del navegador.

Inicializa el SDK de RUM y configura el parámetro de inicialización enableExperimentalFeatures con ["feature_flags"].

npm

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

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

CDN async

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

Sincronización de CDN

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

Para activar la recopilación de datos de indicadores de características para tu aplicación de iOS:

Configura Monitorización de RUM iOS. Necesitas la versión >= 1.16.0 del SDK de iOS RUM.

Para activar la recopilación de datos de indicadores de características para tu aplicación de Android:

Configura Monitorización de RUM Android. Necesitas la versión >= 1.18.0 del SDK de Android RUM.

Para activar la recopilación de datos de indicadores de características para tu aplicación de Flutter:

Configura Monitorización de RUM Flutter. Necesitas la versión >= 1.3.2 del complemento de Flutter.

Para activar la recopilación de datos de indicadores de características para tu aplicación de React Native:

Configura Monitorización de RUM React Native. Necesitas la versión >= 1.7.0 del SDK de React Native RUM.

Establecer una integración de indicadores de características

Puedes empezar a recopilar datos de indicadores de características con soluciones personalizadas de gestión de indicadores de características, o utilizando uno de los socios de integración de Datadog que se enumeran a continuación.

Nota: Los siguientes caracteres especiales no son compatibles con Feature Flag Tracking: . : , +, -, =, &&, ||, >, <, !, (, ), {, }, [, ], ^, ", “, ”, ~, *, ?, \. Datadog recomienda evitar estos caracteres siempre que sea posible en los nombres de los indicadores de características. Si tienes que utilizar uno de estos caracteres, sustitúyelo antes de enviar los datos a Datadog. Por ejemplo

datadogRum.addFeatureFlagEvaluation(key.replace(':', '_'), value);

Integración de Amplitude

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de Amplitude y crea un oyente de exposición que informe de las evaluaciones del indicador de característica a Datadog con el siguiente fragmento de código:

Para más información sobre la inicialización del SDK de Amplitude, consulta la documentación del SDK de JavaScript de Amplitude.

  const experiment = Experiment.initialize("CLIENT_DEPLOYMENT_KEY", {
    exposureTrackingProvider: {
      track(exposure: Exposure)  {
        // Envía el indicador de características cuando Amplitude informa la exposición
        datadogRum.addFeatureFlagEvaluation(exposure.flag_key, exposure.variant);
      }
    }
  })

Inicializa el SDK de Amplitude y crea un inspector que informe de las evaluaciones de los indicadores de característica en Datadog con el siguiente fragmento de código.

Para más información sobre la inicialización del SDK de Amplitude, consulta la documentación del SDK de iOS de Amplitude.

  class DatadogExposureTrackingProvider : ExposureTrackingProvider {
    func track(exposure: Exposure) {
      // Envía el indicador de características cuando Amplitude informa la exposición
      if let variant = exposure.variant {
        RUMMonitor.shared().addFeatureFlagEvaluation(name: exposure.flagKey, value: variant)
      }
    }
  }

  // En el inicio:
  ExperimentConfig config = ExperimentConfigBuilder()
    .exposureTrackingProvider(DatadogExposureTrackingProvider(analytics))
    .build()

Inicializa el SDK de Amplitude y crea un inspector que informe de las evaluaciones de los indicadores de característica en Datadog con el siguiente fragmento de código.

Para más información sobre la inicialización del SDK de Amplitude, consulta la documentación del SDK de Android de Amplitude.

  internal class DatadogExposureTrackingProvider : ExposureTrackingProvider {
    override fun track(exposure: Exposure) {
        // Envía el indicador de características cuando Amplitude informa la exposición
        GlobalRumMonitor.get().addFeatureFlagEvaluation(
            exposure.flagKey,
            exposure.variant.orEmpty()
        )
    }
  }

  // En el inicio:
  val config = ExperimentConfig.Builder()
      .exposureTrackingProvider(DatadogExposureTrackingProvider())
      .build()

Amplitude no admite esta integración. Crea un tique con Amplitude para solicitar esta característica.

Integración de ConfigCat

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Al inicializar el SDK de ConfigCat JavaScript, suscríbete al evento flagEvaluated e informa de las evaluaciones de los indicadores de características a Datadog:

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

Para obtener más información sobre la inicialización del SDK de ConfigCat JavaScript, consulta la documentación del SDK de JavaScript SDK de ConfigCat.

Al inicializar el SDK de ConfigCat Swift iOS, suscríbete al evento flagEvaluated e informa de las evaluaciones de los indicadores de características a 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)
    }
  }

Para obtener más información sobre la inicialización del SDK de Swift (iOS) de ConfigCat, consulta la documentación del SDK de Swift iOS de ConfigCat.

Al inicializar el SDK de ConfigCat Android, suscríbete al evento flagEvaluated e informa de las evaluaciones de los indicadores de características a Datadog:

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

Para más información sobre la inicialización del SDK de ConfigCat Android, consulta la documentación del SDK de Android de ConfigCat.

Al inicializar el SDK de ConfigCat Dart, suscríbete al evento flagEvaluated e informa de las evaluaciones de los indicadores de características a 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);
            }
        )
    )
  );

Para obtener más información sobre la inicialización del SDK de ConfigCat Dart (Flutter), consulta la documentación del SDK de Dart de ConfigCat.

Al inicializar el SDK de ConfigCat React, suscríbete al evento flagEvaluated e informa de las evaluaciones de los indicadores de características a Datadog:

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

Para obtener más información sobre la inicialización del SDK de ConfigCat React, consulta la documentación del SDK de React de ConfigCat.

Gestión de indicadores de características personalizadas

Antes de inicializar esta integración de indicadores de características personalizadas, asegúrate de haber configurado la monitorización de RUM.

Cada vez que se evalúe un indicador de característica, añade la siguiente función para enviar la información del indicador de característica a RUM:

datadogRum.addFeatureFlagEvaluation(key, value);

Cada vez que se evalúe un indicador de característica, añade la siguiente función para enviar la información del indicador de característica a RUM:

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

Cada vez que se evalúe un indicador de característica, añade la siguiente función para enviar la información del indicador de característica a RUM:

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

Cada vez que se evalúe un indicador de característica, añade la siguiente función para enviar la información del indicador de característica a RUM:

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

Cada vez que se evalúe un indicador de característica, añade la siguiente función para enviar la información del indicador de característica a RUM:

DdRum.addFeatureFlagEvaluation(key, value);

Integración de DevCycle

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de DevCycle y suscríbete al evento variableEvaluated, eligiendo suscribirte a todas las evaluaciones de variables variableEvaluated:* o a evaluaciones de variables concretas variableEvaluated:my-variable-key.

Para obtener más información sobre la inicialización del SDK de DevCycle, consulta la documentación del SDK de JavaScript de DevCycle y para obtener más información sobre el sistema de evento de DevCycle, consulta la documentación del evento de 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) => {
        // rastrear todas las evualaciones de variables
        datadogRum.addFeatureFlagEvaluation(key, variable.value);
    }
)
...
dvcClient.subscribe(
    "variableEvaluated:my-variable-key",
    (key, variable) => {
        // rastrear una evaluación de variable particular
        datadogRum.addFeatureFlagEvaluation(key, variable.value);
    }
)

DevCycle no admite esta integración. Crea un tique con DevCycle para solicitar esta característica.

Integración de Eppo

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de Eppo y crea un registrador de asignaciones que informe adicionalmente de las evaluaciones de indicadores de características a Datadog con el fragmento de código que se muestra a continuación.

Para más información sobre la inicialización del SDK de Eppo, consulta la documentación del SDK de Eppo JavaScript.

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

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

Para más información sobre la inicialización del SDK de Eppo, consulta la documentación del SDK de iOS de Eppo.

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

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

Para más información sobre la inicialización del SDK de Eppo, consulta la documentación del SDK de Android de 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 no admite esta integración. Ponte en contacto con Eppo para solicitarla.

Para más información sobre la inicialización del SDK de Eppo, consulta la documentación del SDK de React Native de Eppo.

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

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

Integración de Flagsmith

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de Flagsmith con la opción datadogRum, que informa de las evaluaciones de indicadores de características a Datadog con el fragmento de código que se muestra a continuación.

Opcionalmente, puedes configurar el cliente para que los rasgos de Flagsmith se envíen a Datadog a través de datadogRum.setUser(). Para más información sobre la inicialización del SDK de Flagsmith, consulta la documentación del SDK de JavaScript de Flagsmith.

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

Flagsmith no admite esta integración. Crea un tique con Flagsmith para solicitar esta característica.

Flagsmith no admite actualmente esta integración. Crea un tique con Flagsmith para solicitar esta característica.

Integración de GrowthBook

Al inicializar el SDK de GrowthBook, informa de las evaluaciones del indicador de características a Datadog mediante la devolución de llamada onFeatureUsage.

Para obtener más información sobre la inicialización del SDK de GrowthBook, consulta la documentación del SDK de GrowthBook JavaScript.

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

gb.init();

GrowthBook no admite esta integración. Ponte en contacto con GrowthBook para solicitar esta característica.

Al inicializar el SDK de GrowthBook, informa de las evaluaciones de los indicadores de características a Datadog llamando a setFeatureUsageCallback.

Para obtener más información sobre la inicialización del SDK de GrowthBook, consulta la documentación del SDK de Android de GrowthBook.

val gbBuilder = GBSDKBuilder(...)

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

val gb = gbBuilder.initialize()

Al inicializar el SDK de GrowthBook, informa de las evaluaciones de los indicadores de características a Datadog llamando a setFeatureUsageCallback.

Para obtener más información sobre la inicialización del SDK de GrowthBook, consulta la documentación del SDK de Flutter de GrowthBook.

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

Al inicializar el SDK de GrowthBook, informa de las evaluaciones del indicador de características a Datadog mediante la devolución de llamada onFeatureUsage.

Para obtener más información sobre la inicialización del SDK de GrowthBook, consulta la documentación del SDK de React Native de GrowthBook.

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

gb.init();

Integración de LaunchDarkly

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de LaunchDarkly y crea un inspector que informe de las evaluaciones de los indicadores de característica a Datadog con el siguiente fragmento de código.

Para más información sobre la inicialización del SDK de LaunchDarkly, consulta la documentación del SDK de LaunchDarkly JavaScript.

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 no admite esta integración. Crea un tique con LaunchDarkly para solicitar esta característica.

LaunchDarkly no admite actualmente esta integración. Crea un tique con LaunchDarkly para solicitar esta característica.

Integración de Split

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de Split y crea un receptor de impresiones que informe las evaluaciones de los indicadores de características a Datadog mediante el uso del siguiente fragmento de código:

Para más información sobre la inicialización del SDK de Split, consulta la documentación del SDK de 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();

Inicializa el SDK de Split y crea un inspector que informe de las evaluaciones de los indicadores de característica en Datadog con el siguiente fragmento de código.

Para más información sobre la inicialización del SDK de Split, consulta la documentación del SDK de iOS de Split.

  let config = SplitClientConfig()
  // Envía el indicador de característica cuando Split informa la impresión
  config.impressionListener = { impression in
      if let feature = impression.feature,
          let treatment = impression.treatment {
          RUMMonitor.shared().addFeatureFlagEvaluation(name: feature, value: treatment)
      }
  }

Inicializa el SDK de Split y crea un inspector que informe de las evaluaciones de los indicadores de característica en Datadog con el siguiente fragmento de código.

Para más información sobre la inicialización del SDK de Split, consulta la documentación del SDK de Android de Split.

  internal class DatadogSplitImpressionListener : ImpressionListener {
    override fun log(impression: Impression) {
        // Envía el indicador de característica cuando Split informa la impresión
        GlobalRumMonitor.get().addFeatureFlagEvaluation(
            impression.split(),
            impression.treatment()
        )
    }
    override fun close() {
    }
  }

  // En el inicio:
  val apikey = BuildConfig.SPLIT_API_KEY
  val config = SplitClientConfig.builder()
      .impressionListener(DatadogSplitImpressionListener())
      .build()

Inicializa el SDK de Split y crea un inspector que informe de las evaluaciones de los indicadores de característica en Datadog con el siguiente fragmento de código.

Para más información sobre la inicialización del SDK de Split, consulta la documentación del complemento de Flutter de Split.

  StreamSubscription<Impression> impressionsStream = _split.impressionsStream().listen((impression) {
    // Envía el indicador de característica cuando Split informa la impresión
    final split = impression.split;
    final treatment = impression.treatment;
    if (split != null && treatment != null) {
      DatadogSdk.instance.rum?.addFeatureFlagEvaluation(split, treatment);
    }
  });

Inicializa el SDK de Split y crea un receptor de impresiones que informe las evaluaciones de los indicadores de características a Datadog mediante el uso del siguiente fragmento de código:

Para más información sobre la inicialización del SDK de Split, consulta la documentación del SDK de 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();

Integración de Statsig

Antes de inicializar esta integración de indicadores de características, asegúrate de haber configurado la monitorización de RUM.

Inicializa el SDK de Statsig con statsig.initialize.

Actualiza tu versión de SDK del Navegador RUM a la versión 4.25.0 o posterior.
Inicializa el SDK RUM y configura el parámetro de inicialización enableExperimentalFeatures con ["feature_flags"].

Inicializa el SDK de Statsig (>= v4.34.0) e implementa la opción gateEvaluationCallback como se muestra a continuación:

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