> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.
# SDK de Rust
> Integre el SDK de Rust de Kameleoon para ejecutar experimentos y activar feature flags en servicios y back-ends web Rust.
Con el SDK de Rust de Kameleoon puede ejecutar experimentos y activar feature flags en sus servicios y back-ends web escritos en Rust.
**Primeros pasos**: Para obtener ayuda para comenzar, consulte la [guía del desarrollador](#guía-del-desarrollador).
**Changelog**: Última versión del SDK de Rust: 0.9.3 [Changelog](https://github.com/Kameleoon/client-rust/blob/master/CHANGELOG.md).
**Métodos del SDK**: Para la documentación de referencia completa del SDK de Rust, consulte la sección [referencia](#referencia).
## Guía del desarrollador
Esta guía está diseñada para ayudarle a integrar rápidamente el SDK de Rust y empezar a evaluar feature flags en su aplicación Rust.
### Primeros pasos
#### Instalar el cliente Rust
Si está trabajando en el workspace actual, añada el SDK como dependencia de ruta junto con `tokio`, ya que varios métodos del SDK son asíncronos:
```toml title="Cargo.toml" theme={null}
[dependencies]
kameleoon-client = "0.9.3"
```
#### Configuración adicional
Cree un archivo de configuración `client-rust.json` para proporcionar las credenciales y personalizar el comportamiento del SDK. También puede [descargar nuestro archivo de configuración de ejemplo](/assets/developer-docs/sdks/web-sdks/client-configs/client-config.json).
Recomendamos guardar este archivo en la ruta predeterminada, `/etc/kameleoon/client-rust.json`, pero puede guardarlo en cualquier lugar del classpath con el nombre `client-rust.json`.
El SDK de Rust puede configurarse con un archivo JSON utilizado por `create_with_path()` o construyendo una instancia `KameleoonClientConfig` con `create_with_config()` directamente en el código.
La siguiente tabla muestra las propiedades disponibles que puede establecer:
| Clave (Código / Archivo de configuración) | Descripción | Valor predeterminado |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- |
| `client_id` / `clientId` (*obligatorio*) | Necesario para autenticarse en el servicio Kameleoon. Para encontrar su `client_id`, consulte la documentación de [credenciales de API](/user-manual/account-and-team-management/users-and-teams/api-credentials). | |
| `client_secret` / `clientSecret` (*obligatorio*) | Necesario para autenticarse en el servicio Kameleoon. Para encontrar su `client_secret`, consulte la documentación de [credenciales de API](/user-manual/account-and-team-management/users-and-teams/api-credentials). | |
| `session_duration` / `sessionDurationMinutes` (*opcional*) | Intervalo de tiempo, en minutos, durante el cual el SDK mantiene a un visitante y sus datos asociados en memoria. | `30` minutos |
| `refresh_interval` / `refreshIntervalMinutes` (*opcional*) | Intervalo, en minutos, utilizado para actualizar la configuración de experimentos y feature flags activos. | `60` minutos |
| `default_timeout` / `defaultTimeoutMillis` (*opcional*) | Tiempo de espera predeterminado, en milisegundos, para las solicitudes de red del SDK. | `10000` milisegundos |
| `tracking_interval` / `trackingIntervalMillis` (*opcional*) | Intervalo, en milisegundos, utilizado para agrupar las solicitudes de seguimiento. Los valores se limitan al rango `[1000, 5000]`. | `1000` milisegundos |
| `environment` / `environment` (*opcional*) | Entorno desde el que debe utilizarse la configuración de feature flags. El valor puede ser `production`, `staging` o `development`. | `production` |
| `top_level_domain` / `topLevelDomain` (*opcional*) | El dominio de nivel superior actual de su sitio web. Utilice el formato `example.com`, sin protocolo ni subdominios. | `None` |
| `proxy_host` / `proxyHost` (*opcional*) | Host proxy para las llamadas salientes del SDK. Formatos admitidos: `https://my.prox`, `https://my.prox:4545`, `socks5://192.168.1.1:9000`. | `None` |
| `network_domain` / `networkDomain` (*opcional*) | Dominio personalizado utilizado por los SDKs para las solicitudes salientes, a menudo para hacer proxy. Debe ser un dominio válido (por ejemplo, example.com o sub.example.com). Los formatos no válidos se sustituyen por el valor por defecto de Kameleoon. | `None` |
#### Inicializar el cliente Kameleoon
Una vez que haya instalado el SDK y configurado sus credenciales, cree un `KameleoonClient` mediante `KameleoonClientFactory`.
```rust theme={null}
use std::time::Duration;
use kameleoon_client::config::KameleoonClientConfigBuilder;
use kameleoon_client::factory::KameleoonClientFactory;
async fn create_client() -> Result {
let site_code = "a8st4f59bj";
let client = KameleoonClientFactory::create_with_path(site_code, "/etc/kameleoon/client-rust.json")?;
client.initialize().await?;
Ok(client)
}
```
```rust theme={null}
use std::time::Duration;
use kameleoon_client::config::KameleoonClientConfigBuilder;
use kameleoon_client::factory::KameleoonClientFactory;
async fn create_client() -> Result {
let site_code = "a8st4f59bj";
let config = KameleoonClientConfigBuilder::default()
.client_id("".to_owned()) // mandatory
.client_secret("".to_owned()) // mandatory
.refresh_interval(Duration::from_mins(60)) // optional (60 minutes by default)
.session_duration(Duration::from_mins(30)) // optional (30 minutes by default)
.default_timeout(Duration::from_millis(10_000)) // optional (10000 ms by default)
.tracking_interval(Duration::from_millis(1_000)) // optional (10000 ms by default)
.environment("development".to_owned()) // optional
.top_level_domain(".example.com") // mandatory if you use hybrid mode (engine or web experiments)
.proxy_host("http://192.168.0.25:8080".to_owned()) // optional
.network_domain("example.com".to_owned()) // optional
.build()
.unwrap();
let client = KameleoonClientFactory::create_with_config(site_code, config)?;
client.initialize().await?;
Ok(client)
}
```
Un `KameleoonClient` es el objeto principal utilizado para evaluar feature flags, añadir datos de visitantes y enviar solicitudes de seguimiento.
* Se recomienda utilizar `KameleoonClient` como un objeto singleton, ya que actúa como puente entre su aplicación y la plataforma Kameleoon. Expone todos los métodos y propiedades necesarios para ejecutar experimentos de forma eficiente.
* El SDK de Rust se inicializa de forma asíncrona. Debe llamar a [`initialize()`](#initialize) antes de depender de la evaluación de funcionalidades en código de producción.
#### Activación de un feature flag
##### Asignar un ID único a un usuario
Para asignar un ID único a un usuario puede utilizar el método [`get_visitor_code()`](#get_visitor_code). Si no existe un **código de visitante** (en la cookie de las cabeceras de la solicitud), el método genera un ID único aleatorio o utiliza un `default_visitor_code` que usted haya generado. A continuación, el ID se establece en una cookie de cabeceras de respuesta.
Si utiliza Kameleoon en [modo híbrido](/developer-docs/feature-experimentation/get-started/hybrid-experimentation), llamar al método `get_visitor_code()` garantiza que el ID único (**código de visitante**) se comparta entre el archivo de aplicación `engine.js` (anteriormente denominado `kameleoon.js`) y el SDK.
##### Recuperar la configuración de un flag
Para implementar un feature flag en su código, primero debe crear el feature flag en su cuenta Kameleoon.
Para determinar el estado o la variación de un feature flag para un usuario específico, debe usar el método [`get_variation()`](#get_variation) o [`is_feature_active()`](#is_feature_active) para recuperar la configuración basada en `feature_key`.
El método `get_variation()` gestiona tanto feature flags simples con estados ON/OFF como flags más complejos con varias variaciones. El método recupera la variación adecuada para el usuario comprobando las reglas de la funcionalidad, asignando la variación y devolviéndola según `feature_key` y `visitor_code`.
El método `is_feature_active()` puede utilizarse si desea recuperar la configuración de un feature flag simple que solo tiene un estado ON u OFF, en contraposición a feature flags más complejos con varias variaciones u opciones de segmentación.
Si su feature flag tiene variables asociadas (como comportamientos específicos vinculados a cada variación), `get_variation()` también le permite acceder al objeto [`Variation`](#variation), que proporciona detalles sobre la variación asignada y su experimento asociado. Este método comprueba si el usuario está segmentado, encuentra la variación asignada al visitante y la guarda en el almacenamiento. Cuando `track=true`, el SDK enviará el evento de exposición al experimento especificado en la próxima solicitud de seguimiento, que se activa automáticamente según el [`tracking_interval`](#configuración-adicional) del SDK. Por defecto, este intervalo está establecido en 1000 milisegundos (1 segundo).
El método `get_variation()` le permite controlar si se realiza el seguimiento. Si `track=false`, el SDK no enviará eventos de exposición. Esto es útil si prefiere no rastrear datos a través del SDK y en su lugar utilizar el seguimiento del lado del cliente gestionado, por ejemplo, por el engine de Kameleoon. Además, establecer `track=false` es útil cuando se utiliza el método `get_variations()`, donde es posible que solo necesite las variaciones de todos los flags sin desencadenar ningún evento de seguimiento. Si desea saber más sobre cómo funciona el seguimiento, consulte [este artículo](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics)
##### Añadir puntos de datos para segmentar a un usuario o filtrar / desglosar visitas en los informes
Para segmentar a un usuario, asegúrese de haber añadido los puntos de datos relevantes a su perfil antes de recuperar la variación de la funcionalidad o de comprobar si el flag está activo. Utilice el método [`add_data()`](#add_data) para añadir estos puntos de datos al perfil del usuario.
Para recuperar puntos de datos recopilados en otros dispositivos o para acceder a datos pasados del usuario (recopilados del lado del cliente cuando se utiliza Kameleoon en modo híbrido), use el método [`get_remote_visitor_data()`](#get_remote_visitor_data). Este método obtiene datos del servidor de forma asíncrona. Es importante llamar a `get_remote_visitor_data()` *antes* de recuperar la variación o comprobar si el feature flag está activo, ya que estos datos pueden ser necesarios para asignar a un usuario a una variación determinada.
Para obtener más información sobre las condiciones de segmentación disponibles, consulte el [artículo detallado sobre el tema](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).
Además, los puntos de datos que añada al perfil del visitante estarán disponibles al analizar sus experimentos, lo que le permitirá filtrar y desglosar los resultados por factores como el dispositivo y el navegador. El modo híbrido de Kameleoon recopila automáticamente una variedad de puntos de datos del lado del cliente, lo que facilita el desglose de los resultados según estos datos preexistentes. Consulte la lista completa [aquí](/es/user-manual/experiment-analytics/analyze-results/results-page/results-page-settings#desglose-de-audiencia).
Si necesita rastrear puntos de datos adicionales más allá de lo que se recopila automáticamente, puede usar la [funcionalidad de Datos Personalizados](#customdata) de Kameleoon. Los datos personalizados le permiten capturar y analizar información específica relevante para sus experimentos. No olvide llamar al método [`flush()`](#flush) para enviar los datos recopilados a los servidores de Kameleoon para su análisis.
Para garantizar que sus resultados sean precisos, se recomienda filtrar los bots utilizando el tipo de datos [`UserAgent`](#useragent).
##### Seguimiento de conversiones de objetivos
Cuando un usuario completa una acción deseada (como realizar una compra), se registra como una conversión. Para rastrear conversiones, utilice el método [`track_conversion()`](#track_conversion) y proporcione los parámetros obligatorios `visitor_code` y `goal_id`.
La solicitud de seguimiento de la conversión se enviará junto con la siguiente solicitud de seguimiento programada, que el SDK envía a intervalos regulares (definidos por [`tracking_interval`](#configuración-adicional)). Si prefiere enviar la solicitud inmediatamente, utilice el método [`flush_instant()`](#flush).
##### Enviar eventos a soluciones de analítica
Para rastrear conversiones y enviar eventos de exposición a su solución de analítica de cliente, primero debe implementar Kameleoon en [modo híbrido](/developer-docs/feature-experimentation/get-started/hybrid-experimentation/). A continuación, utilice el método [`get_engine_tracking_code()`](#get_engine_tracking_code).
El método `get_engine_tracking_code()` recupera el código único de seguimiento necesario para enviar eventos de exposición a su solución de analítica. El uso de este método le permite registrar eventos y enviarlos a la plataforma de analítica que desee.
### Uso de una clave de bucketing personalizada
De forma predeterminada, Kameleoon utiliza un ID único y anónimo del visitante (`visitor_code`) para asignar a los usuarios a las variaciones de los feature flags. Este ID se genera y se almacena normalmente en el dispositivo del usuario (en una cookie del navegador para los SDKs cliente y servidor, en almacenamiento persistente para los SDKs móviles). Sin embargo, en determinados escenarios es posible que necesite garantizar que todos los usuarios de una misma organización vean la misma variante de un feature flag.
La opción **Clave de bucketing personalizada** le permite anular este comportamiento predeterminado proporcionando su propio identificador personalizado para el bucketing. Esta anulación garantiza que la lógica de asignación de Kameleoon utilice la clave especificada en lugar del `visitor_code` predeterminado.
#### Casos de uso
Utilizar una clave de bucketing personalizada es esencial para mantener la coherencia y la precisión en las asignaciones de feature flags, especialmente en estas situaciones:
* **Experimentos a nivel de cuenta u organización:** para productos B2B o escenarios en los que quiera asignar a todos los usuarios de la misma organización a la misma variación, puede usar un identificador como `account_id`. Las claves de bucketing personalizadas son cruciales para los tests A/B de funcionalidades que afectan a todo un equipo o empresa.
Al implementar una clave de bucketing personalizada, garantiza mayor coherencia y precisión en sus experimentos, lo que se traduce en resultados más fiables y en una mejor experiencia del usuario.
#### Detalles técnicos
Cuando configura una clave de bucketing personalizada para un feature flag, proporciona a Kameleoon un identificador específico de los datos de su aplicación:
```rust theme={null}
use kameleoon_client::data::CustomData;
client.add_data(visitor_code, [CustomData::new(42, vec!["new_visitor_code".to_owned()])])?;
```
* **Proporcionar la clave personalizada:** proporciona su identificador personalizado al SDK de Kameleoon mediante el método [`add_data()`](#add_data). En este método pasará la clave de bucketing personalizada elegida como objeto [`CustomData`](#customdata). Aquí, `new_visitor_code` se refiere al identificador que desea utilizar para su bucketing (por ejemplo, el nuevo `user_id` o `account_id`).
Para que la clave de bucketing personalizada funcione correctamente, también debe estar definida y configurada para el feature flag durante el proceso de creación o edición del flag. Sin esta configuración correspondiente, el bucketing del SDK no aplicará su clave personalizada. Para obtener instrucciones detalladas sobre cómo configurarlo en Kameleoon, consulte este [artículo](/user-manual/experimentation/feature-experimentation/create-and-manage-flags/create-a-feature-flag#Advanced_Flag_Settings).
* **Lógica de bucketing:** una vez proporcionada la clave de bucketing personalizada mediante el método `add_data()`, todos los cálculos de hash para asignar usuarios a variaciones utilizarán este `new_visitor_code` (su clave personalizada) en lugar del `visitor_code` predeterminado. El uso de `new_visitor_code` significa que la decisión de bucketing se vincula a su identificador personalizado, garantizando asignaciones coherentes en distintos contextos donde dicho identificador esté presente.
* **Seguimiento de datos y analítica:** es crucial tener en cuenta que, aunque se utiliza `new_visitor_code` (su clave personalizada) para las decisiones de bucketing, **todos los datos posteriores (eventos de seguimiento y conversiones, por ejemplo) se envían y se asocian con el `visitor_code` *original*.** Esta separación garantiza que sus analíticas reflejen con precisión los recorridos e interacciones individuales de los usuarios dentro del contexto más amplio de su experimento, incluso cuando el bucketing se realiza a un nivel superior (como una cuenta) o a través de varios dispositivos/sesiones. Sus datos originales de visitante permanecen intactos para informes completos.
#### Requisitos técnicos
Para utilizar eficazmente una clave de bucketing personalizada:
* La clave debe ser un `&str`.
* Debe ser única para la entidad que tiene la intención de bucketizar (por ejemplo, si utiliza `user_id`, el ID de cada usuario debe ser único).
* La clave debe estar disponible para el SDK en el momento exacto en el que se evalúa la decisión del feature flag para ese usuario o solicitud.
### Condiciones de segmentación
Los SDKs de Kameleoon admiten una variedad de condiciones de segmentación predefinidas que puede utilizar para segmentar a los usuarios en sus campañas. Para conocer la lista de condiciones que admite este SDK, consulte [usar el historial de visitas para segmentar usuarios](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).
También puede utilizar sus propios [datos externos para segmentar a los usuarios](/developer-docs/apis/data-api-rest/tutorials/storing-and-retrieving-external-data-to-target-users).
### Experimentación cross-device
Para dar soporte a los visitantes que acceden a una aplicación desde varios dispositivos, Kameleoon permite sincronizar los datos del visitante recopilados previamente en cada uno de los dispositivos del visitante y reconciliar su historial de visitas entre dispositivos mediante la experimentación cross-device. Los casos de estudio e información detallada sobre cómo Kameleoon gestiona los datos entre dispositivos están disponibles en el [artículo sobre experimentación cross-device](/developer-docs/cross-device-experimentation).
#### Sincronizar custom data entre dispositivos
Aunque la sincronización de custom mapping se utiliza para alinear los datos del visitante entre dispositivos, no siempre es necesaria. A continuación se describen dos escenarios en los que no se requiere la sincronización de custom mapping:
**Mismo ID de usuario entre dispositivos**
Si el mismo ID de usuario se utiliza de forma coherente en todos los dispositivos, la sincronización se gestiona automáticamente sin necesidad de sincronización de custom mapping. Basta con llamar al método `get_remote_visitor_data()` cuando se desee sincronizar los datos recopilados entre varios dispositivos.
**Instancias multiservidor con IDs coherentes**
En configuraciones complejas con varios servidores (por ejemplo, instancias de servidor distribuidas), donde el mismo ID de usuario está disponible en los distintos servidores, la sincronización entre servidores (con `get_remote_visitor_data()`) es suficiente sin necesidad de una sincronización adicional de custom mapping.
Los clientes que necesiten datos adicionales pueden consultar la descripción del método [`get_remote_visitor_data()`](#get_remote_visitor_data) para obtener más orientación. En el siguiente código, se asume que el mismo identificador único (en este caso, el `visitor_code`, que también puede denominarse `userId`) se utiliza de forma coherente entre los dos dispositivos para una recuperación de datos precisa.
Si desea sincronizar los datos recopilados en tiempo real, debe elegir el ámbito **Visitor** para sus custom data.
```rust title="Dispositivo A" theme={null}
// In this example, a Custom data with index `90` was set to "Visitor" scope in Kameleoon.
use kameleoon_client::data::CustomData;
const VISITOR_SCOPE_CUSTOM_DATA_INDEX: u32 = 90;
client.add_data(visitor_code, [CustomData::new(VISITOR_SCOPE_CUSTOM_DATA_INDEX, vec!["your data".to_owned()])])?;
client.flush_instant(visitor_code).await?;
```
```rust title="Dispositivo B" theme={null}
// Before working with the data, call the `get_remote_visitor_data` method.
client.get_remote_visitor_data(visitor_code, None).await?;
// After calling the method, the SDK on Device B will have access to CustomData of Visitor scope defined on Device A.
// So, "your data" will be available for targeting and tracking the visitor.
```
#### Uso de custom data para la fusión de sesiones
La [experimentación cross-device](/developer-docs/cross-device-experimentation) permite combinar el historial de un visitante entre cada uno de sus dispositivos (reconciliación del historial). La reconciliación del historial permite fusionar distintas sesiones del visitante en una sola. Para reconciliar el historial de visitas, utilice [`CustomData`](#customdata) para proporcionar un identificador único del visitante. Para más información, consulte la [documentación específica](/developer-docs/cross-device-experimentation/#activating-cross-device-history-reconciliation).
Una vez activada la reconciliación cross-device, llamar a [`get_remote_visitor_data()`](#get_remote_visitor_data) con el parámetro `userId` recupera todos los datos conocidos de un usuario determinado.
A las sesiones con el mismo identificador siempre se les mostrará la misma variación en un experimento. En la vista de Visitante de las páginas de resultados de su experimento, estas sesiones aparecerán como un único visitante.
La configuración del SDK garantiza que las sesiones asociadas siempre vean la misma variación del experimento. Sin embargo, existen algunas limitaciones respecto a la asignación de variaciones cross-device. Estas limitaciones se describen [aquí](/developer-docs/cross-device-experimentation#critical-points-and-practical-insights).
Siga la guía [activación de la reconciliación cross-device del historial](#experimentación-cross-device) para configurar su custom data en la plataforma Kameleoon.
Posteriormente, podrá utilizar el SDK con normalidad. Los siguientes métodos pueden resultar útiles en el contexto de la fusión de sesiones:
* `get_remote_visitor_data()` con `UniqueIdentifier(true)` añadido: para recuperar datos de todos los visitantes vinculados.
* [`track_conversion()`](#track_conversion) o [`flush()`](#flush) con datos `UniqueIdentifier(true)` añadidos: para rastrear datos específicos de un visitante que está asociado a otro visitante.
Dado que el custom data que utilice como identificador debe configurarse en ámbito **Visitor**, debe utilizar la [sincronización cross-device de custom data](/developer-docs/cross-device-experimentation) para recuperar el identificador con el método [`get_remote_visitor_data()`](#get_remote_visitor_data) en cada dispositivo.
Aquí tiene un ejemplo de cómo usar custom data para la fusión de sesiones.
```rust theme={null}
// In this example, 91 represents the Custom Data's index configured as a unique identifier in Kameleoon.
use kameleoon_client::data::{CustomData, UniqueIdentifier};
const MAPPING_INDEX: u32 = 91;
const FEATURE_KEY: &str = "ff123";
let anonymous_visitor_code = "anonymous-visitor";
let user_id = "authenticated-user";
// 1. Before the visitor is authenticated
// Retrieve the variation for an unauthenticated visitor.
// Assume anonymousVisitorCode is the randomly generated ID for that visitor.
let anonymous_variation = client.get_variation(anonymous_visitor_code, FEATURE_KEY)?;
// 2. After the visitor is authenticated
// Assume `userId` is the visitor code of the authenticated visitor.
client.add_data(anonymous_visitor_code, [CustomData::new(MAPPING_INDEX, vec![user_id.to_owned()])])?;
client.flush_instant(anonymous_visitor_code).await?;
// Indicate that `userId` is a unique identifier.
client.add_data(user_id, [UniqueIdentifier::new(true)])?;
// 3. After the visitor was authorized
// Retrieve the variation for the `userId`, which will match the anonymous visitor code's variation.
let user_variation = client.get_variation(user_id, FEATURE_KEY)?;
let is_same_variation = user_variation.key == anonymous_variation.key; // True
// `userId` and `anonymousVisitorCode` are now linked and can be tracked as a single visitor.
client.track_conversion(user_id, 123)?;
// Additionally, the linked visitors share all fetched previously tracked remote data.
client.get_remote_visitor_data(user_id, None).await?;
```
En este ejemplo, la aplicación tiene una página de inicio de sesión. Como el ID de usuario es desconocido en el momento del login, se utiliza un identificador anónimo de visitante generado por el método [`get_visitor_code()`](#get_visitor_code). Tras iniciar sesión, el visitante anónimo se asocia con el ID de usuario y se utiliza como identificador único del visitante.
### Logging
El SDK genera logs para reflejar diversos procesos e incidencias internos.
#### Niveles de log
El SDK admite la configuración del logging limitándolo por nivel de log.
```rust theme={null}
use kameleoon_client::logging::{KameleoonLogger, LogLevel};
// The `None` log level does not allow logging.
KameleoonLogger::set_log_level(LogLevel::None);
// The `Error` log level only allows logging issues that may affect the SDK's primary behaviour.
KameleoonLogger::set_log_level(LogLevel::Error);
// The `Warning` log level allows logging issues which may require an attention.
// It extends the `ERROR` log level.
// The `WARNING` log level is a default log level.
KameleoonLogger::set_log_level(LogLevel::Warning);
// The `Info` log level allows logging general information on the SDK's internal processes.
// It extends the `WARNING` log level.
KameleoonLogger::set_log_level(LogLevel::Info);
// The `Debug` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to our support team
// to assist with internal troubleshooting.
KameleoonLogger::set_log_level(LogLevel::Debug);
```
#### Gestión personalizada de los logs
De forma predeterminada, el SDK escribe sus logs en la salida de consola. Este comportamiento puede sobrescribirse.
La limitación del logging por nivel de log se realiza independientemente de la lógica de gestión de los logs.
```rust theme={null}
use kameleoon_client::logging::{KameleoonLogger, LogLevel, Logger};
use log::{error, warn, info, debug};
pub struct CustomLogger;
impl Logger for CustomLogger {
// `log` method accepts logs from the SDK
fn log(&self, log_level: LogLevel, message: &str) {
// Custom log handling logic here. For example:
match log_level {
LogLevel::Error => error!("{}", message),
LogLevel::Warning => warn!("{}", message),
LogLevel::Info => info!("{}", message),
LogLevel::Debug => debug!("{}", message),
}
}
}
// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
KameleoonLogger::set_log_level(LogLevel::Debug); // Optional; defaults to `LogLevel.WARNING`.
KameleoonLogger::set_logger(Box::new(CustomLogger));
```
## Referencia
Esta es la documentación de referencia completa del SDK de Rust.
### Inicialización
#### create()
Para utilizar el SDK, cree un `KameleoonClient` a partir de una instancia de `KameleoonClientConfig` con `KameleoonClientFactory::create_with_config()`/`KameleoonClientFactory::create_with_file()`.
```rust theme={null}
use std::time::Duration;
use kameleoon_client::config::KameleoonClientConfigBuilder;
use kameleoon_client::factory::KameleoonClientFactory;
let config = KameleoonClientConfigBuilder::default()
.client_id("".to_owned()) // mandatory
.client_secret("".to_owned()) // mandatory
.refresh_interval(Duration::from_mins(60)) // optional (60 minutes by default)
.session_duration(Duration::from_mins(30)) // optional (30 minutes by default)
.default_timeout(Duration::from_millis(10_000)) // optional (10000 ms by default)
.tracking_interval(Duration::from_millis(1_000)) // optional (10000 ms by default)
.environment("development".to_owned()) // optional
.top_level_domain(".example.com") // mandatory if you use hybrid mode (engine or web experiments)
.proxy_host("http://192.168.0.25:8080".to_owned()) // optional
.network_domain("example.com".to_owned()) // optional
.build()
.unwrap();
let client = KameleoonClientFactory::create_with_config(site_code, config)?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| --------------------------- | ----------------------- | -------------------------------------------------------- |
| `site_code` (*obligatorio*) | `&str` | Clave única del proyecto Kameleoon utilizado por el SDK. |
| `config` (*obligatorio*) | `KameleoonClientConfig` | Objeto de configuración del SDK. |
```rust theme={null}
use kameleoon_client::factory::KameleoonClientFactory;
let client = KameleoonClientFactory::create_with_file("a8st4f59bj", "/etc/kameleoon/client-rust.json")?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| ----------------------------- | ------ | -------------------------------------------------------- |
| `site_code` (*obligatorio*) | `&str` | Clave única del proyecto Kameleoon utilizado por el SDK. |
| `config_path` (*obligatorio*) | `&str` | Ruta al archivo de configuración JSON. |
##### Valor devuelto
| Tipo | Descripción |
| ----------------------------------------- | ----------------------------------------------------------------------------------------- |
| `Result` | Una instancia de cliente en caso de éxito; en caso contrario, un error de inicialización. |
##### Errores
| Tipo | Descripción |
| ------------------------------------- | -------------------------------------------- |
| `ErrorCode::ConfigCredentialsInvalid` | Faltan las credenciales del SDK. |
| `ErrorCode::SiteCodeIsEmpty` | El código de sitio proporcionado está vacío. |
#### initialize()
Espera a que el cliente Kameleoon se inicialice utilizando el [`default_timeout`](#configuración-adicional) configurado o un `timeout` proporcionado. Este método garantiza que el cliente esté completamente inicializado antes de realizar cualquier otra operación.
```rust theme={null}
use std::time::Duration;
// Initializes the client using the configured default timeout
client.initialize().await?;
// Initializes the client with a custom timeout of 5 seconds
client.initialize_with_timeout(Duration::from_secs(5)).await?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| ---------------------- | ---------- | ----------------------------------------------- |
| `timeout` (*opcional*) | `Duration` | Tiempo máximo de espera para la inicialización. |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Indica si la inicialización se completó correctamente o si se produjo un error. |
##### Errores
| Tipo | Descripción |
| --------------------------- | --------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
#### is\_ready()
Comprueba si el cliente ha sido inicializado.
```rust theme={null}
if client.is_ready() {
// The client is ready
}
```
##### Valor devuelto
| Tipo | Descripción |
| ------ | ------------------------------------------------------------------------ |
| `bool` | `true` si el cliente está listo para usarse; en caso contrario, `false`. |
#### forget()
Elimina el cliente del SDK en caché asociado al `site_code` especificado.
```rust theme={null}
use kameleoon_client::factory::KameleoonClientFactory;
// Removes the cached client for the given site code
KameleoonClientFactory::forget("a8st4f59bj")?;
// Removes the cached client for the given site code and environment
KameleoonClientFactory::forget_with_environment("a8st4f59bj", "production")?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| --------------------------- | ------ | ---------------------------------------------- |
| `site_code` (*obligatorio*) | `&str` | Identificador único del proyecto Kameleoon. |
| `environment` (*opcional*) | `&str` | Clave de entorno asociada al cliente en caché. |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | -------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Indica si el cliente en caché se eliminó correctamente o si se produjo un error. |
### Feature flags y variaciones
#### is\_feature\_active()
* 📨 *Envía datos de seguimiento a Kameleoon (según la opción `track`)*
Determina si un feature flag está activo para un usuario determinado.
Si el visitante aún no ha sido evaluado para este feature flag, el SDK evalúa las reglas de targeting y devuelve el resultado. Si el visitante ya tiene una evaluación almacenada para la funcionalidad, el SDK reutiliza el resultado existente para garantizar la coherencia.
Kameleoon utiliza el seguimiento para contabilizar sesiones y visitantes cuando llama a determinados métodos, como `is_feature_active()`, `get_variation()` o `get_variations()`.
Utilice el valor predeterminado `true` para el parámetro `track` cuando exponga a los visitantes a una variación y necesite contabilizarlos. Establezca el parámetro `track` en `false` solo si llama a estos métodos antes de exponer a los visitantes.
Por ejemplo, si llama a `get_variations()` para recuperar todas las variaciones antes de exponer a los visitantes, establezca el parámetro `track` en `false`. Esta configuración evita que Kameleoon contabilice prematuramente una sesión. Posteriormente podrá activar el seguimiento cuando exponga explícitamente al visitante.
Kameleoon envía los datos de seguimiento cada segundo por defecto. Puede configurar este intervalo hasta cinco segundos mediante la opción de configuración del intervalo de seguimiento. Kameleoon agrupa los eventos de seguimiento en una única sesión siempre que el intervalo entre eventos sea inferior a 30 minutos. Si transcurren más de 30 minutos entre eventos de seguimiento, Kameleoon los cuenta como sesiones separadas. Una visita aparece en sus informes 30 minutos después del último evento registrado en la sesión.
El método `is_feature_active()` evalúa la variante servida, no el estado del flag maestro. Si excluye reglas, el método utiliza el estado predeterminado **Entonces, para todos los demás servir**. Si selecciona **Off** para este estado predeterminado, el método siempre devolverá `false` incluso cuando el feature flag maestro esté **On**.
```rust theme={null}
use kameleoon_client::client::IsFeatureActiveOpts;
let feature_key = "new_checkout";
// Evaluates the feature flag and sends tracking data (default behavior)
let active = client.is_feature_active(visitor_code, feature_key)?;
// Evaluates the feature flag without sending tracking data
let active_without_tracking = client.is_feature_active_with_opts(
visitor_code,
feature_key,
IsFeatureActiveOpts::new().track(false),
)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ------------------------------ | ------ | ----------------------------------------------------------------------- | ----------- |
| `visitor_code` (*obligatorio*) | `&str` | Identificador único del usuario. | |
| `feature_key` (*obligatorio*) | `&str` | Clave de la funcionalidad que se va a evaluar para el usuario. | |
| `track` (*opcional*) | `bool` | Activa o desactiva el seguimiento de la evaluación de la funcionalidad. | `true` |
##### Valor devuelto
| Tipo | Descripción |
| ------------------------------ | ---------------------------------------------------------------------------------------------- |
| `Result` | Indica si el feature flag está activo para el `visitor_code` especificado o devuelve un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::FeatureNotFound` | Excepción que indica que la clave de funcionalidad solicitada no se encontró en la configuración interna del SDK. Esto suele significar que el feature flag no está activado en la aplicación Kameleoon (pero el código que implementa la funcionalidad ya está desplegado en la aplicación). |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
#### get\_variation()
* 📨 *Envía datos de seguimiento a Kameleoon (según el parámetro `track`)*
Recupera la [`Variation`](#variation) asignada a un visitante determinado para un feature flag específico.
Este método toma `visitor_code` y `feature_key` como argumentos obligatorios. El argumento `track` es opcional y su valor predeterminado es `true`.
Devuelve la `Variation` asignada al visitante. Si el visitante no está asociado a ninguna regla de feature flag, el método devuelve la `Variation` por defecto para el feature flag indicado.
Asegúrese de que su código implementa un manejo de errores adecuado para gestionar las posibles excepciones.
La variación por defecto se refiere a la variación asignada a un visitante cuando este no coincide con ninguna regla de entrega predefinida para un feature flag. Dicho de otro modo, es la variación de respaldo que se aplica a todos los usuarios que no son segmentados por reglas específicas. Está representada por la variación de la sección "Entonces, para todos los demás..." en una interfaz de gestión.
```rust theme={null}
use kameleoon_client::client::GetVariationOpts;
let feature_key = "new_checkout";
// Retrieves the variation assigned to the visitor (with tracking enabled by default)
let variation = client.get_variation(visitor_code, feature_key)?;
// Retrieves the variation without sending tracking data
let variation_without_tracking = client.get_variation_with_opts(
visitor_code,
feature_key,
GetVariationOpts::new().track(false),
)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ----------------------------- | ------ | ---------------------------------------------------------------------------------------------------- | ----------- |
| visitor\_code (*obligatorio*) | `&str` | Identificador único del visitante. | |
| feature\_key (*obligatorio*) | `&str` | Clave de la funcionalidad que desea exponer a un visitante. | |
| track (*opcional*) | `bool` | Un parámetro opcional para activar o desactivar el seguimiento de la evaluación de la funcionalidad. | `true` |
##### Valor devuelto
| Tipo | Descripción |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Result` | Una [`Variation`](#variation) asignada a un visitante determinado para un feature flag específico en caso de éxito; en caso contrario, un error. |
##### Errores
| Tipo | Descripción |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
| `ErrorCode::FeatureNotFound` | Excepción que indica que la clave de funcionalidad solicitada no se encontró en la configuración interna del SDK. Esto suele significar que el feature flag no está activado en la aplicación Kameleoon (pero el código que implementa la funcionalidad ya está desplegado en la aplicación). |
| `ErrorCode::FeatureEnvironmentDisabled` | Excepción que indica que el feature flag está deshabilitado para el entorno actual del visitante (por ejemplo, producción, staging o desarrollo). |
| `ErrorCode::FeatureEvaluationBlocked` | Excepción que indica que la evaluación de la funcionalidad está bloqueada. El motivo se describe en el mensaje de error. Esto suele producirse debido a restricciones del RGPD cuando el visitante no ha dado su consentimiento legal. |
#### get\_variations()
* 📨 *Envía datos de seguimiento a Kameleoon (según el parámetro `track`)*
Recupera un mapa de objetos [`Variation`](#variation) asignados a un visitante determinado en todos los feature flags.
Este método itera sobre todos los feature flags disponibles y devuelve la `Variation` asignada para cada flag asociado al visitante especificado. Toma `visitor_code` como argumento obligatorio, mientras que `only_active` y `track` son opcionales.
* Si `only_active` se establece en `true`, el método `get_variations()` devolverá las variaciones de los feature flags siempre que el usuario no esté bucketizado en la variación `off`.
* El parámetro `track` controla si el método rastrea o no las asignaciones de variaciones. Por defecto, está establecido en `true`. Si se establece en `false`, el seguimiento se desactivará.
El mapa devuelto consta de las claves de los feature flags como claves y su `Variation` correspondiente como valores. Si no hay variación asignada para un feature flag, el método devuelve la `Variation` por defecto para ese flag.
Debe implementarse un manejo de errores adecuado para gestionar las posibles excepciones.
La variación por defecto se refiere a la variación asignada a un visitante cuando este no coincide con ninguna regla de entrega predefinida para un feature flag. Dicho de otro modo, es la variación de respaldo que se aplica a todos los usuarios que no son segmentados por reglas específicas. Está representada por la variación de la sección "Entonces, para todos los demás..." en una interfaz de gestión.
```rust theme={null}
use kameleoon_client::client::GetVariationsOpts;
// Retrieves all variations assigned to the visitor (with default options)
let variations = client.get_variations(visitor_code)?;
// Retrieves only active variations for the visitor
let only_active_variations = client.get_variations_with_opts(
visitor_code,
GetVariationsOpts::new().only_active(true),
)?;
// Retrieves variations without sending tracking data
let variations_without_tracking = client.get_variations_with_opts(
visitor_code,
GetVariationsOpts::new().track(false),
)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ----------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------- | ----------- |
| visitor\_code (*obligatorio*) | `&str` | Identificador único del visitante. | |
| only\_active (*opcional*) | `bool` | Un parámetro opcional que indica si devolver las variaciones para los feature flags activos (`true`) o para todos (`false`). | `false` |
| track (*opcional*) | `bool` | Un parámetro opcional para activar o desactivar el seguimiento de la evaluación de la funcionalidad. | `true` |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Result, KameleoonError>` | Mapa que contiene los objetos [`Variation`](#variation) asignados de los feature flags utilizando las claves de las funcionalidades correspondientes en caso de éxito; en caso contrario, un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
#### set\_forced\_variation()
El método le permite asignar de forma programática una [`Variation`](#variation) específica a un usuario, omitiendo el proceso de evaluación estándar. Esto resulta especialmente valioso en experimentos controlados en los que no se requiere la lógica habitual de evaluación o debe omitirse. También puede ser útil en escenarios como la depuración o las pruebas personalizadas.
Cuando se establece una variación **forzada**, esta anula la lógica de evaluación en tiempo real de Kameleoon. Se omiten procesos como la segmentación, las condiciones de targeting y los cálculos algorítmicos. Para conservar la segmentación y las condiciones de targeting durante un experimento, establezca `force_targeting=false` en su lugar.
Las variaciones **simuladas** siempre tienen prioridad en el orden de ejecución. Si se activa el cálculo de una variación **simulada**, esta se procesará y completará primero por completo.
Una variación forzada se trata igual que una variación evaluada. Se rastrea en la analítica y se almacena en el contexto del usuario como cualquier variación estándar evaluada, garantizando la coherencia en los informes.
El método puede lanzar excepciones en determinadas condiciones (por ejemplo, parámetros no válidos, contexto del usuario o problemas internos). Es esencial un manejo adecuado de las excepciones para garantizar que su aplicación siga siendo estable y resiliente.
Es importante distinguir las variaciones **forzadas** de las variaciones **[simuladas](#get_visitor_code)**:
* **Variaciones forzadas**: son específicas de un experimento individual.
* **Variaciones simuladas**: afectan al resultado global del **feature flag**.
```rust theme={null}
use kameleoon_client::client::SetForcedVariationOpts;
let experiment_id = 202387;
// Forces the visitor into "variation_2" for the given experiment
client.set_forced_variation(visitor_code, experiment_id, Some("variation_2"))?;
// Removes any previously forced variation for the visitor in this experiment
client.set_forced_variation(visitor_code, experiment_id, None)?;
// Forces the visitor into "variation_2" with custom options
// In this case, targeting rules are respected (force_targeting = false)
client.set_forced_variation_with_opts(
visitor_code,
experiment_id,
Some("variation_2"),
SetForcedVariationOpts::new().force_targeting(false),
)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ------------------------------ | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| visitor\_code (*obligatorio*) | `&str` | Identificador único del visitante. | |
| experiment\_id (*obligatorio*) | `u32` | **ID del experimento** que será segmentado y seleccionado durante el proceso de evaluación. | |
| variation\_key (*obligatorio*) | `Option<&str>` | **Clave de variación** correspondiente a una `Variation` que debe forzarse como valor devuelto para el experimento. Si el valor es `None`, la variación forzada se restablecerá. | |
| force\_targeting (*opcional*) | `bool` | Indica si la segmentación del experimento debe forzarse y omitirse (`true`) o aplicarse como en el proceso de evaluación estándar (`false`). | `true` |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ------------------------------------------------------------------------------------ |
| `Result<(), KameleoonError>` | Indica si la variación forzada se estableció correctamente o si se produjo un error. |
##### Errores
| Tipo | Descripción |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
| `ErrorCode::FeatureExperimentNotFound` | Excepción que indica que el ID del experimento solicitado no se ha encontrado en la configuración interna del SDK. Esto suele ser normal y significa que el experimento correspondiente a la regla aún no se ha activado en el lado de Kameleoon. |
| `ErrorCode::FeatureVariationNotFound` | Excepción que indica que la clave (id) de la variación solicitada no se ha encontrado en la configuración interna del SDK. Esto suele ser normal y significa que el experimento correspondiente a la variación aún no se ha activado en el lado de Kameleoon. |
#### evaluate\_audiences()
* 📨 *Envía datos de seguimiento a Kameleoon*
Este método evalúa a los visitantes frente a todos los segmentos disponibles de Audiences Explorer y rastrea a aquellos que coinciden.
`evaluate_audiences()` debe llamarse **después de que se hayan establecido o actualizado todos los datos relevantes del visitante**, y **justo antes** de obtener una variación de funcionalidad o comprobar un feature flag. Este enfoque garantiza que el visitante sea evaluado con los datos más actuales disponibles, lo que permite una asignación precisa de audiencias en función de todos los criterios.
Tras llamar a este método, puede realizar un análisis detallado del rendimiento de los segmentos en Audiences Explorer.
```rust theme={null}
client.evaluate_audiences(visitor_code)?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| ----------------------------- | ------ | ---------------------------------- |
| visitor\_code (*obligatorio*) | `&str` | Identificador único del visitante. |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ---------------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Indica si la evaluación de audiencias se realizó correctamente o si se produjo un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
#### get\_datafile()
Para evaluar todos los feature flags, utilice [`get_variations()`](#get_variations). Este método es más eficiente que llamar a `DataFile` e iterar sobre los flags con [`get_variation()`](#get_variation).
Devuelve la configuración actual del SDK como un objeto [`DataFile`](#datafile).
```rust theme={null}
let datafile = client.get_datafile()?;
```
##### Valor devuelto
| Tipo | Descripción |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `Result, KameleoonError>` | El [`DataFile`](#datafile) que contiene la configuración del SDK en caso de éxito; en caso contrario, un error. |
##### Errores
| Tipo | Descripción |
| --------------------------- | --------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
### Datos del visitante
#### get\_visitor\_code()
Utilice `get_visitor_code()` para obtener el `visitor_code` de Kameleoon del visitante actual. El método funciona con cualquier almacén de cookies que implemente el trait `CookieAccessor`.
La lógica de implementación es la siguiente:
1. El SDK comprueba si ya hay una cookie `kameleoonVisitorCode` disponible a través del accesor proporcionado.
2. Si la cookie no está presente, el SDK utiliza `default_visitor_code` si lo proporciona.
3. En caso contrario, el SDK genera un nuevo código de visitante y lo almacena a través del accesor.
Para más información, consulte [Experimentación híbrida](/developer-docs/feature-experimentation/get-started/hybrid-experimentation/).
Si proporciona su propio `visitor_code`, su unicidad debe estar garantizada por su parte. Tenga en cuenta también que la longitud de `visitor_code` está limitada a `255` caracteres.
El método `get_visitor_code()` le permite establecer variaciones **simuladas** para un visitante. Cuando las cookies (de una **request** o **document**) contienen la clave `kameleoonSimulationFFData`, el proceso de evaluación estándar se omite. En su lugar, el método devuelve directamente una [`Variation`](#variation) basada en los datos proporcionados.
Puede aplicar simulaciones de dos formas:
* **Automáticamente (recomendado):** si utiliza Kameleoon Web Experimentation o el SDK en [modo híbrido](/developer-docs/feature-experimentation/get-started/hybrid-experimentation#linking-feature-experiments-with-front-end-tracking-code), la cookie se crea automáticamente al simular la visualización de una variante mediante el [Panel de Simulación](/user-manual/experimentation/feature-experimentation/using-the-rollout-planner/validation-and-rollback/using-simulation-mode).
* **Manualmente:** establezca la cookie `kameleoonSimulationFFData` manualmente.
Es importante distinguir las variaciones **simuladas** de las variaciones **[forzadas](#set_forced_variation)**:
* **Variaciones simuladas**: afectan al resultado global del **feature flag**.
* **Variaciones forzadas**: son específicas de un experimento individual.
⚙️ **Configuración manual**
Asegúrese de que la cookie `kameleoonSimulationFFData` sigue este formato:
* `kameleoonSimulationFFData={"featureKey":{"expId":10,"varId":20}}`: simula la variación con `varId` del experimento `expId` para el `featureKey` indicado.
* `kameleoonSimulationFFData={"featureKey":{"expId":0}}`: simula la variación por defecto (definida en la sección **Entonces, para todos los demás en Producción, servir**) para el `featureKey` indicado.
⚠️ Para garantizar el correcto funcionamiento, el valor de la cookie debe codificarse como componente URI mediante un método como [`encodeURIComponent`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent).
```rust theme={null}
use std::collections::HashMap;
use kameleoon_client::cookies::CookieAccessor;
// A simple in-memory cookie store, useful for testing or non-HTTP environments
struct MemoryCookies {
values: HashMap,
}
impl CookieAccessor for MemoryCookies {
// Store the cookie value by key (max_age and top_level_domain are unused here)
fn set<'a>(&mut self, key: &str, value: &str, _max_age: u32, _top_level_domain: Option<&'a str>) {
self.values.insert(key.to_owned(), value.to_owned());
}
// Retrieve a cookie value by key
fn get(&self, key: &str) -> Option<&str> {
self.values.get(key).map(String::as_str)
}
}
// Generate or retrieve a visitor code using auto-generated value
let visitor_code = client.get_visitor_code(&mut cookies, None)?;
// Generate or retrieve a visitor code using a predefined user ID
let visitor_code = client.get_visitor_code(&mut cookies, Some("user_id"))?;
```
```rust theme={null}
use axum::{ extract::State, http::StatusCode, response::{IntoResponse, Response} };
use axum_extra::extract::cookie::{Cookie, CookieJar};
use kameleoon_client::client::KameleoonClient;
use kameleoon_client::cookies::CookieAccessor;
use time::Duration;
// Wrapper around Axum's CookieJar to implement the CookieAccessor trait
struct AxumCookies(CookieJar);
impl CookieAccessor for AxumCookies {
// Build and add a cookie with path, max_age, and optional domain, then insert into the jar
fn set<'a>(&mut self, key: &str, value: &str, max_age: u32, top_level_domain: Option<&'a str>) {
let mut builder =
Cookie::build((key.to_owned(), value.to_owned())).path("/").max_age(Duration::seconds(i64::from(max_age)));
if let Some(domain) = top_level_domain {
builder = builder.domain(domain.to_owned());
}
self.0 = std::mem::take(&mut self.0).add(builder.build());
}
// Retrieve a cookie value by key from the jar
fn get(&self, key: &str) -> Option<&str> {
self.0.get(key).map(|cookie| cookie.value())
}
}
async fn get_visitor_code(
State(client): State,
jar: CookieJar,
) -> Result<(StatusCode, CookieJar, String), Response> {
let mut cookies = AxumCookies(jar);
// Retrieve or generate a visitor code; map any SDK error to a 500 response
let visitor_code = client
.get_visitor_code(&mut cookies, None)
.map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()).into_response())?;
// Return the status, updated cookie jar, and visitor code in the response
Ok((StatusCode::OK, cookies.0, visitor_code))
}
```
```rust theme={null}
use actix_web::{ HttpRequest, HttpResponse, cookie::Cookie, http::{StatusCode, header}, web};
use kameleoon_client::client::KameleoonClient;
use kameleoon_client::cookies::CookieAccessor;
use kameleoon_client::error::KameleoonError;
use time::Duration;
// Holds both request cookies (read-only) and response cookies (to be set on the client)
struct ActixCookies<'a> {
request: Ref<'a, Vec>>,
response: Vec>,
}
impl CookieAccessor for ActixCookies<'_> {
// Build a cookie with path, max_age, and optional domain;
// update it if it already exists in the response, otherwise append it
fn set<'a>(&mut self, key: &str, value: &str, max_age: u32, top_level_domain: Option<&'a str>) {
let mut builder =
Cookie::build(key.to_owned(), value.to_owned()).path("/").max_age(Duration::seconds(i64::from(max_age)));
if let Some(domain) = top_level_domain {
builder = builder.domain(domain.to_owned());
}
let next_cookie = builder.finish();
match self.response.iter_mut().find(|cookie| cookie.name() == key) {
Some(cookie) => *cookie = next_cookie,
None => self.response.push(next_cookie),
}
}
// Check response cookies first, then fall back to request cookies
fn get(&self, key: &str) -> Option<&str> {
self.response
.iter()
.find(|cookie| cookie.name() == key)
.map(|cookie| cookie.value())
.or_else(|| self.request.iter().find(|cookie| cookie.name() == key).map(|cookie| cookie.value()))
}
}
fn get_visitor_code(client: web::Data, request: HttpRequest) -> Result {
// Parse cookies from the incoming request
let request_cookies = request.cookies().map_err(|error| error.to_string())?;
let mut cookies = ActixCookies {
request: request_cookies,
response: Vec::new(),
};
// Retrieve or generate a visitor code using the SDK
let visitor_code = client.get_visitor_code(&mut cookies, None)?;
// Attach any new/updated cookies to the response headers
let mut response = HttpResponse::build(StatusCode::OK);
for cookie in cookies.response {
response.append_header((header::SET_COOKIE, cookie.encoded().to_string()));
}
Ok(response.body(visitor_code))
}
```
##### Argumentos
| Nombre | Tipo | Descripción |
| ----------------------------------- | -------------------------- | ----------------------------------------------------------------------------------- |
| `cookies` (*obligatorio*) | `&mut impl CookieAccessor` | Accesor de cookies mutable utilizado para leer y almacenar la cookie del visitante. |
| `default_visitor_code` (*opcional*) | `Option<&str>` | Código de visitante a utilizar cuando no hay ninguna cookie presente. |
##### Valor devuelto
| Tipo | Descripción |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `Result` | Cadena que representa un código único de visitante utilizado en el SDK en caso de éxito; en caso contrario, un error. |
#### add\_data()
El método `add_data()` añade [datos de targeting](#tipos-de-datos) al almacenamiento para que otros métodos puedan usar los datos para decidir si segmentar o no al visitante actual.
El método `add_data()` no devuelve ningún valor y no interactúa por sí solo con los servidores back-end de Kameleoon. En su lugar, todos los datos declarados se guardan para su transmisión futura mediante el método [`flush()`](#flush). Este enfoque reduce el número de llamadas al servidor realizadas, ya que los datos se suelen agrupar en una única llamada al servidor que se desencadena con `flush()`.
El método [`track_conversion()`](#track_conversion) también envía cualquier dato previamente asociado, igual que `flush()`. Lo mismo ocurre con los métodos [`get_variation()`](#get_variation) y [`get_variations()`](#get_variations) si se activa una regla de experimentación.
Cada visitante solo puede tener una instancia de datos asociados para la mayoría de tipos de datos. Sin embargo, [`CustomData`](#customdata) es una excepción. Los visitantes pueden tener una instancia de `CustomData` asociada por índice.
```rust theme={null}
use kameleoon_client::data::{Browser, BrowserKind, PageView, UserAgent};
client.add_data(visitor_code, [Browser::new(BrowserKind::Chrome, Some(123.0))])?;
client.add_data(
visitor_code,
[
PageView::new("https://example.com/pricing".to_owned(), Some("Pricing".to_owned()), vec![3]).into(),
UserAgent::new("Mozilla/5.0".to_owned()).into(),
],
)?;
client.add_data_with_track(
visitor_code,
vec![PageView::new("https://example.com/checkout".to_owned(), Some("Checkout".to_owned()), vec![])],
false,
)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Valor por defecto |
| ----------------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
| visitor\_code (*obligatorio*) | `&str` | Identificador único del visitante. | |
| data (*obligatorio*) | `impl IntoIterator- >` | Colección de tipos de datos de Kameleoon. | |
| track (*opcional*) | `bool` | Especifica si los datos añadidos son elegibles para el seguimiento. Si se establece en `false`, los datos se almacenan localmente y solo se utilizan para la evaluación de la segmentación; no se envían a la API de datos de Kameleoon. | `true` |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ------------------------------------------------------------------------ |
| `Result<(), KameleoonError>` | Indica si los datos se añadieron correctamente o si se produjo un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
#### flush()
* *📨 Envía datos de seguimiento a Kameleoon*
El método `flush()` agrega todos los datos Kameleoon asociados a un visitante y envía una solicitud de seguimiento al servidor. Esta solicitud incluye los datos añadidos previamente mediante el método [`add_data`](#add_data) que aún no se hayan transmitido a través de otros mecanismos de seguimiento (consulte los métodos referenciados para más detalles). La operación `flush()` no es bloqueante, ya que la llamada al servidor se realiza de forma asíncrona.
Este método proporciona control sobre cuándo se transmiten los datos vinculados a un `visitor_code` específico. Por ejemplo, si se llama a `add_data()` varias veces, enviar una solicitud tras cada invocación sería ineficiente. En su lugar, puede agrupar estas actualizaciones y llamar a `flush()` una vez para enviar todos los datos acumulados en una sola solicitud.
El método `flush()` utiliza el `visitor_code` proporcionado como identificador único del visitante.
* `flush()`: pone en cola una operación de flush según el intervalo de seguimiento configurado.
* `flush_instant()`: envía los datos de seguimiento de inmediato sin esperar al intervalo.
```rust theme={null}
// Queues a flush operation for the given visitor_code.
// Data will be sent according to the configured tracking interval (non-blocking).
client.flush(visitor_code)?;
// Immediately sends all pending tracking data for the given visitor_code.
// This is an async operation and must be awaited.
client.flush_instant(visitor_code).await?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| ------------------------------ | ------ | ---------------------------------- |
| `visitor_code` (*obligatorio*) | `&str` | Identificador único del visitante. |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ------------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Indica si la operación se programó o ejecutó correctamente, o si se produjo un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
#### get\_remote\_data()
El método `get_remote_data()` le permite recuperar datos remotos almacenados en los servidores de Kameleoon para el `key` especificado. En la mayoría de las configuraciones, estos datos se escriben a través de la API de datos de Kameleoon y pueden recuperarse posteriormente por su servicio Rust cuando necesite contexto adicional de la aplicación.
Este método es útil cuando desea mantener información estructurada en la infraestructura remota de Kameleoon y reutilizarla desde su back-end sin tener que mantener un mecanismo de recuperación independiente.
```rust theme={null}
let data = client.get_remote_data("test-key").await?;
```
##### Argumentos
| Nombre | Tipo | Descripción |
| --------------------- | ------ | ------------------------------------------------------- |
| `key` (*obligatorio*) | `&str` | Clave asociada a los datos remotos que desea recuperar. |
##### Valor devuelto
| Tipo | Descripción |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Result` | Carga útil (payload) asociada a la `key` especificada en caso de éxito; en caso contrario, un error. En la mayoría de los casos, el payload es JSON serializado como cadena. |
##### Errores
| Tipo | Descripción |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::Network` | Se devuelve cuando la solicitud de datos remotos falla o el servidor responde con un código de estado no exitoso. |
#### get\_remote\_visitor\_data()
`get_remote_visitor_data()` es un método asíncrono para recuperar los datos de visita de Kameleoon del `visitor_code` proporcionado. El método añade los datos al almacenamiento local del visitante para que otros métodos del SDK puedan utilizarlos en decisiones de targeting.
Los datos obtenidos con este método son especialmente útiles cuando se desea:
* utilizar datos recopilados desde otros dispositivos.
* acceder al historial de un visitante, como páginas vistas previamente en visitas anteriores.
* utilizar datos que solo están disponibles del lado del cliente, como variables del datalayer y conversiones de objetivos del front-end.
Lea [este artículo](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation) para comprender mejor los posibles casos de uso.
De forma predeterminada, `get_remote_visitor_data()` recupera automáticamente los datos personalizados almacenados más recientes con `scope=Visitor` y los adjunta al visitante sin necesidad de llamar a [`add_data()`](#add_data). Esto es especialmente útil para [sincronizar datos personalizados entre varios dispositivos](/developer-docs/cross-device-experimentation/).
```rust theme={null}
use kameleoon_client::types::RemoteVisitorDataFilter;
// Fetch remote visitor data without any filter
// This will return all available data for the given visitor
client.get_remote_visitor_data(visitor_code, None).await?;
// Create a filter to limit the returned data
let filter = RemoteVisitorDataFilter {
// Include data from the last 5 visits
previous_visit_amount: 5,
// Include conversion events (e.g., goals, transactions)
conversions: true,
// Include page view history
page_views: true,
// Use default values for all other fields
..Default::default()
};
// Fetch remote visitor data using the specified filter
// This will return only the data matching the filter criteria
client.get_remote_visitor_data(visitor_code, Some(filter)).await?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ------------------------------ | --------------------------------- | ---------------------------------------------------------------------- | ------------------------------------ |
| `visitor_code` (*obligatorio*) | `&str` | Código de visitante cuyos datos deben recuperarse. | |
| `filter` (*opcional*) | `Option` | Filtro que describe qué datos remotos del visitante deben recuperarse. | `RemoteVisitorDataFilter::default()` |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `Result<(), KameleoonError>` | Se devuelve correctamente cuando los datos se recuperan y se añaden localmente; en caso contrario, un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
| `ErrorCode::Network` | Se devuelve cuando la solicitud de datos remotos del visitante falla, no puede analizarse o el servidor responde con un código de estado no exitoso. |
##### Uso de parámetros en get\_remote\_visitor\_data()
El método `get_remote_visitor_data()` le permite controlar qué datos se recuperan de un visitante. El mismo enfoque de filtrado funciona para objetivos, experimentos, variaciones y otros datos del visitante.
Por ejemplo, si desea segmentar a los usuarios que convirtieron en un objetivo durante sus últimas cinco visitas, puede establecer `previous_visit_amount` en `5` y `conversions` en `true`.
La flexibilidad mostrada en este ejemplo no se limita a los datos de objetivos. Puede usar el filtro para recuperar muchos comportamientos diferentes del visitante y ponerlos a disposición de la lógica de targeting y de informes en su aplicación Rust.
##### Campos de `RemoteVisitorDataFilter`
| Nombre | Tipo | Descripción | Por defecto |
| ----------------------- | ------ | ------------------------------------------------------------------------ | ----------- |
| `previous_visit_amount` | `i32` | Número de visitas anteriores de las que se recuperan datos. | `1` |
| `current_visit` | `bool` | Si es `true`, se recuperarán los datos de la visita actual. | `true` |
| `custom_data` | `bool` | Si es `true`, se recuperarán los datos personalizados. | `true` |
| `visitor_code` | `bool` | Si es `true`, se reutilizará el código de visitante más reciente. | `true` |
| `page_views` | `bool` | Si es `true`, se recuperarán los datos de páginas vistas. | `false` |
| `geolocation` | `bool` | Si es `true`, se recuperarán los datos de geolocalización. | `false` |
| `device` | `bool` | Si es `true`, se recuperarán los datos del dispositivo. | `false` |
| `browser` | `bool` | Si es `true`, se recuperarán los datos del navegador. | `false` |
| `operating_system` | `bool` | Si es `true`, se recuperarán los datos del sistema operativo. | `false` |
| `conversions` | `bool` | Si es `true`, se recuperarán los datos de conversiones. | `false` |
| `experiments` | `bool` | Si es `true`, se recuperarán los datos de experimentos. | `false` |
| `kcs` | `bool` | Si es `true`, se recuperarán los datos del Kameleoon Conversion Score. | `false` |
| `personalizations` | `bool` | Si es `true`, se recuperarán los datos de personalización. | `false` |
| `cbs` | `bool` | Si es true, se recuperarán los datos de la puntuación Contextual Bandit. | `false` |
#### get\_visitor\_warehouse\_audience()
Este método recupera los datos de audiencia asociados a un visitante en su integración de warehouse utilizando el `visitor_code` especificado y, opcionalmente, una `warehouse_key`. La `warehouse_key` suele ser su ID de usuario interno. El parámetro `custom_data_index` corresponde al custom data de Kameleoon que Kameleoon utiliza para segmentar a sus visitantes.
Cuando la llamada tiene éxito, el SDK convierte la lista de audiencias devuelta en [`CustomData`](#customdata), la añade al visitante localmente y la pone disponible para fines de targeting. Para más información, consulte la [documentación sobre targeting de warehouse](/user-manual/integrations/data-warehouses/bigquery/use-bigquery-as-a-source-audience-targeting).
```rust theme={null}
// Fetch audience data for a visitor using only the visitor_code.
client.get_visitor_warehouse_audience(visitor_code, None, 98).await?;
// Fetch audience data for a visitor using both visitor_code and warehouse_key.
// Useful when your warehouse uses a different identifier than visitor_code.
client.get_visitor_warehouse_audience(visitor_code, Some("internal-user-id"), 98).await?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ----------------------------------- | -------------- | ---------------------------------------------------------------------------------------------- | -------------- |
| `visitor_code` (*obligatorio*) | `&str` | Visitante cuyas audiencias del warehouse deben recuperarse. | |
| `warehouse_key` (*opcional*) | `Option<&str>` | Clave externa del warehouse, normalmente su ID de usuario interno. | `visitor_code` |
| `custom_data_index` (*obligatorio*) | `u32` | Índice del custom data configurado en Kameleoon para el targeting de audiencias del warehouse. | |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Éxito cuando los datos de audiencia del warehouse se recuperan y se almacenan localmente como `CustomData`. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
| `ErrorCode::Network` | Se devuelve cuando la solicitud de audiencia del warehouse falla, no puede analizarse o el servidor responde con un código de estado no exitoso. |
#### set\_legal\_consent()
Debe utilizar este método para especificar si el visitante ha dado su consentimiento legal para utilizar datos personales. Establecer `legal_consent` en `false` limita los tipos de datos que pueden incluirse en las solicitudes de seguimiento. Esto le ayuda a cumplir los requisitos legales y normativos al tiempo que gestiona los datos del visitante de forma responsable. Para más información, consulte la [política de gestión del consentimiento](/user-manual/project-management/consent-management-policy).
Si proporciona un accesor de cookies, el SDK también actualiza las cookies del visitante según el estado del consentimiento.
```rust theme={null}
// Set consent and update cookies
client.set_legal_consent(visitor_code, true, Some(&mut cookies))?;
// Set consent without updating cookies
client.set_legal_consent(visitor_code, true, None)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ------------------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| `visitor_code` (*obligatorio*) | `&str` | Identificador único del usuario. | |
| `legal_consent` (*obligatorio*) | `bool` | `true` indica que el visitante ha dado su consentimiento legal; `false` indica que el visitante nunca ha proporcionado o ha retirado el consentimiento legal. | |
| `cookies` (*opcional*) | `Option<&mut impl CookieAccessor>` | Accesor de cookies opcional utilizado para actualizar las cookies. | `None` |
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Indica si el estado de consentimiento del visitante se actualizó correctamente o, en caso contrario, un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
##### Comportamiento de la revocación del consentimiento
Cuando llama a `set_legal_consent()` con `legal_consent=false`, el SDK no elimina la cookie `kameleoonVisitorCode`. En su lugar, deja de prolongar la fecha de expiración de la cookie, permitiendo que persista hasta que expire de forma natural.
Si sus requisitos de cumplimiento exigen la eliminación inmediata del archivo de cookie tras la exclusión, debe eliminarlo manualmente utilizando los métodos nativos de gestión de cookies de su framework. El SDK no eliminará el archivo automáticamente.
### Objetivos y analítica de terceros
#### track\_conversion()
* 📨 *Envía datos de seguimiento a Kameleoon*
Utilice este método para rastrear una conversión para un [objetivo](/user-manual//assets/goals/create-a-goal) y usuario específicos. Este método requiere `visitor_code` y `goal_id`. Además, este método también acepta los argumentos opcionales `revenue`, `negative` y `metadata`. El `visitor_code` suele ser idéntico al que se utilizó al activar el experimento.
Este método no es bloqueante, ya que la llamada al servidor se realiza de forma asíncrona.
```rust theme={null}
use kameleoon_client::client::TrackConversionOpts;
use kameleoon_client::data::CustomData;
// Track a goal
client.track_conversion(visitor_code, goal_id)?;
// Track a goal with revenue
client.track_conversion_with_opts(visitor_code, goal_id, TrackConversionOpts::new().revenue(100.0))?;
// Track a goal with negative revenue
client.track_conversion_with_opts(
visitor_code,
goal_id,
TrackConversionOpts::new().revenue(100.0).negative(true)
)?;
// Track a goal with custom metadata
client.track_conversion_with_opts(
visitor_code,
goal_id,
TrackConversionOpts::new().metadata(vec![CustomData::new(4, vec!["true".to_owned()])]),
)?;
```
##### Argumentos
| Nombre | Tipo | Descripción | Por defecto |
| ----------------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| visitor\_code (*obligatorio*) | `&str` | Identificador único del visitante. | |
| goal\_id (*obligatorio*) | `u32` | ID del objetivo. | |
| negative (*opcional*) | `bool` | Define si los ingresos son positivos o negativos. | `false` |
| revenue (*opcional*) | `f32` | Ingresos de la conversión. | `0` |
| metadata (*opcional*) | `Vec` | Metadatos de la conversión. [Deben definirse previamente en la aplicación Kameleoon](/es/user-manual/assets/goals/create-a-goal#metadatos). | `vec![]` |
Los valores de los metadatos son accesibles a través de las [exportaciones de datos sin procesar](/user-manual/experiment-analytics/analyze-results/results-page/results-page-actions#Export) y de [la página de resultados](/user-manual/experiment-analytics/analyze-results/data-and-metrics/goal-metadata).
Si se proporciona el parámetro `metadata`, Kameleoon utilizará estos valores especificados para la conversión actual en lugar de lo que se haya recopilado previamente con el método [`add_data()`](#add_data). Si se omite el parámetro, Kameleoon utilizará los últimos valores rastreados para esos [`CustomData`](#customdata) antes de la conversión y dentro de la misma visita.
Kameleoon solo considerará los valores de metadatos que se pasen explícitamente como parámetros al método `track_conversion()`.
En el ejemplo siguiente, Kameleoon asociará la conversión únicamente con el valor del custom data proporcionado explícitamente como parámetro (aquí: índice 5 con el valor 'Amex Credit Card').
```rust theme={null}
client.add_data(
visitor_code,
[
CustomData::new(5, vec!["Credit Card".to_owned()]),
CustomData::new(9, vec!["Express Delivery".to_owned()])
]
)?;
client.track_conversion_with_opts(
visitor_code,
goal_id,
TrackConversionOpts::new().metadata(vec![CustomData::new(5, vec!["Amex Credit Card".to_owned()])]),
)?
```
##### Valor devuelto
| Tipo | Descripción |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `Result<(), KameleoonError>` | Indica si la conversión se encoló correctamente para seguimiento asíncrono o, en caso contrario, un error. |
##### Errores
| Tipo | Descripción |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `ErrorCode::Initialization` | Indica que el SDK aún no está completamente inicializado. |
| `ErrorCode::VisitorCodeInvalid` | Excepción que indica que el código de visitante proporcionado no es válido. Está vacío o tiene más de 255 caracteres. |
#### get\_engine\_tracking\_code()
Kameleoon se integra con varias soluciones de analítica, incluidas Mixpanel, Google Analytics 4 y Segment. Para rastrear correctamente los experimentos del lado del servidor, llame al método `get_engine_tracking_code()` después de que el visitante active un experimento. El SDK devuelve comandos de cola JavaScript para los experimentos que el visitante activó durante los cinco segundos anteriores. Cuando inserta este código en la página, Engine.js procesa los comandos y envía los eventos de exposición a través de la integración de analítica activa.
Consulte la [experimentación híbrida](/developer-docs/feature-experimentation/get-started/hybrid-experimentation) para más información sobre cómo implementar este método.
```rust theme={null}
let tracking_code = client.get_engine_tracking_code(visitor_code)?;
```
* Para utilizar esta funcionalidad, implemente tanto el SDK de Rust como [Engine.js](/developer-docs/web-experimentation/implementation-and-deployment/standard-implementation) de Kameleoon. Como Engine.js solo se utiliza para el seguimiento en este flujo, puede instalar el tag asíncrono antes de la etiqueta de cierre `
`.
* Si solo quiere rastrear experimentos en Kameleoon y no necesita enviar eventos de exposición a herramientas de analítica de terceros, utilice el [SDK de JavaScript / TypeScript](/developer-docs/sdks/web-sdks/js-sdk). Esta opción funciona bien para [plataformas de cómputo edge serverless](/developer-docs/feature-experimentation/implementation-and-deployment/serverless-edge-compute-starter-kits). El SDK de JavaScript / TypeScript rastrea automáticamente las variaciones cuando se llama a [`getVisitorCode`](/developer-docs/sdks/web-sdks/js-sdk#getvisitorcode), siempre que se añadan las asignaciones de experimentos correspondientes a `window.kameleoonQueue`..
* Puede insertar el código de seguimiento devuelto directamente en una etiqueta `