Guide du groupe témoin global pour les sections utilisant des campagnes API

Le test de contrôle global est une méthode permettant de mesurer l’impact global de votre programme d’expérimentation. La mesure est effectuée à l’aide d’un test A/B qui divise votre trafic global en deux groupes (les utilisateurs qui reçoivent des expériences Dynamic Yield personnalisées et ceux qui n’en reçoivent pas) et les compare. Ce dernier groupe est le groupe témoin global, ou GCG.

Cet article décrit plusieurs options pour implémenter le GCG dans les campagnes API. Discutez avec votre équipe de compte des options qui vous conviennent le mieux.

La mise en place d’un GCG nécessite les étapes suivantes :

Étape 1 : Attribuer des utilisateurs au GCG

Étape 2 : Ajouter des expériences au GCG

Étape 3 : Configurer les rapports pour le GCG

Étape 1 : Affecter des utilisateurs au groupe témoin global

Il existe deux options pour affecter des utilisateurs au groupe témoin global ou au groupe Dynamic Yield Experience.

Option A : Déterminer l’affectation dans votre base de code et la transmettre à Dynamic Yield (recommandé)

1. Implémentez un code tel que les exemples suivants dans votre base de code afin qu’il s’exécute avant la première requête API au point de terminaison Dynamic Yield Choose. Vérifiez si l’utilisateur possède déjà le cookie « _dy_cs_gcg » et, si ce n’est pas le cas, décider de la version de GCG qu’il recevra.

const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.use(cookieParser());
app.use((req, res, next) => {
  if (!req.cookies._dy_cs_gcg) { // si une valeur gcg existe déjà
    const control_percentage = 5;
    const isControl = Math.floor(Math.random() * 100) < control_percentage;
    const gcValue = isControl ? 'Control Group' : 'Dynamic Yield Experiences';
    res.cookie('_dy_cs_gcg', gcValue, { // stocke un nouveau cookie de valeur gcg
      expires: new Date(Date.now() + 31540000000000), // définit une expiration d’un an pour le nouveau cookie
    });
  }
  next();
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`);
});

<?php declare(strict_types=1);

class GroupType
{
    /**
     * Nom du cookie
     */
    protected $_cookieName = '_dy_cs_gcg';

    /**
     * Type du groupe
     */
    protected $_groupType = null;

    /**
     * Get user group type
     * @return string
     */
    public function getGroupType(): string
    {
        if (!isset($_COOKIE[$this->_cookieName])) {
            $controlPercentage = 5;
            $isControl = rand(1, 100) < $controlPercentage;
            $this->_groupType = $isControl ? 'Control Group' : 'Dynamic Yield Experiences';
            setcookie($this->_cookieName, $this->_groupType, time() + (86400 * 365), '/');
        } else {
            $this->_groupType = $_COOKIE[$this->_cookieName];
        }
        return $this->_groupType;
    }
}

from flask import Flask, render_template, make_response, request, Response
import requests
import random
import datetime

app = Flask(__name__)
COOKIE_KEY = '_dy_cs_gcg'


@app.before_request
def gcg_interceptor() -> None:
    if not request.cookies.get(COOKIE_KEY):
        control_percentage = 5
        is_control = random.randint(1, 100) <= control_percentage
        gc_value = 'Control Group' if is_control else 'Dynamic Yield Experiences'
        expire_date = datetime.datetime.now() + datetime.timedelta(days=365)
        request.gc_cookie = (COOKIE_KEY, gc_value, expire_date)


@app.route('/')
def render_demo_page() -> Response:
    resp = make_response(render_template('demopage.html'))
    if hasattr(request, 'gc_cookie'):
        key, value, expiration = request.gc_cookie
        resp.set_cookie(key, value, expires=expiration)
    return resp


@app.route('/get-dy-content')
def get_dy_content() -> Response:
    if (request.cookies.get(COOKIE_KEY) == 'Control Group'):
        return make_response('', 204)
    else:
        # CALL TO DY API CAMPAIGN

2. Utilisez la valeur de gcValue dans l’option pageAttributes de toutes vos demandes Choose pour indiquer à Dynamic Yield si cet utilisateur doit être placé dans le groupe témoin ou dans le groupe Dynamic Yield Experience. 

curl --request POST \
    --url https://dy-api.com/v2/serve/user/choose \
   --header 'content-type: application/json' \
   --header 'DY-API-Key: baadc6ba740a352c9106dc7857a7eb9c' \
   --data '{
    "user": {
    "dyid": "-4350463893986789401",
    "dyid_server": "-4350463893986789401"
    },
    "session": {"dy": "ohyr6v42l9zd4bpinnvp7urjjx9lrssw"},
    "selector": {"names": ["PDP Top Banner"]},
    "context": {
    "page": {
    "type": "PRODUCT",
    "data": ["7383723-010"],
    "location": "https://sugoi-ne.com/men-pants/p7383723-010",
    "locale": "en_US"
    },
    "device": {
    "userAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
    "ip": "54.100.200.255"
    },
    "pageAttributes": { "globalControlGroup": "Dynamic Yield Experiences" }
    },
 }'

3. In your response to the browser, set the correct value for the "_dy_cs_gcg" cookie as a response header with a 1-year expiration date, as shown in the Exemple NodeJS : Ce cookie peut éventuellement être utilisé pour toute expérience côté client que vous prévoyez d’ajouter au GCG (voir Ajouter des expériences côté client au GCG).

Option B : Faire une demande d’API pour le GCG avant de faire d’autres demandes d’API

Cette option est moins rationnelle, car elle nécessite deux appels API distincts pour Dynamic Yield pour les nouveaux utilisateurs avant le rendu.

1. Créez une nouvelle campagne API personnalisée et nommez-la Test de contrôle global.
2. Créez une expérience appelée Test de contrôle global.
3. Créez une variation appelée Dynamic Yield Experiences avec le code JSON suivant :

{"_dy_cs_gcg":"Dynamic Yield Experiences"}

4. Créez une autre variation appelée Groupe témoin avec le code JSON suivant :

{ "_dy_cs_gcg" : "Control" }

5. Définissez l’allocation à 95 % pour les Dynamic Yield Experience et à 5 % pour le groupe témoin.
6. Publiez la campagne.
7. Lors de la première consultation de page, vérifiez si l’utilisateur possède déjà le cookie « _dy_cs_gcg » et, si ce n’est pas le cas, faites une demande d’API pour la campagne Test de contrôle global uniquement. Utilisez la valeur de « _dy_cs_gcg » dans l’option pageAttributes de la requête Choose pour les autres campagnes de la page.
8. Dans votre réponse au navigateur, définissez la valeur correcte du cookie « _dy_cs_gcg » en tant qu’en-tête de réponse, avec une date d’expiration d’un an. Ce cookie peut éventuellement être utilisé pour toute expérience côté client que vous prévoyez d’ajouter au GCG (voir Ajouter des expériences côté client au GCG).

Étape 2 : Ajouter des expériences au GCG

L’ajout d’une expérience au GCG est différent selon qu’il s’agit d’une expérience API ou d’une expérience de script. 

API Experience

Accédez à l’API Experience que vous souhaitez ajouter au test de contrôle global et utilisez la condition de ciblage de l’attribut personnalisé pour la cibler sur le groupe Dynamic Yield Experiences.

Expériences côté client

Étape 1 : Créer l’évaluateur

L’évaluateur est utilisé pour cibler les expériences vers le groupe Dynamic Yield Experience ou le groupe témoin.

1. Créez un évaluateur nommé Groupe témoin global.

2. Définissez le type de valeur sur « String ».

3. Définissez Expected Values (valeurs attendues) sur « Dynamic Yield Experiences and Control Group » (expériences de Dynamic Yield et Groupe témoin).

4. Insérez le code suivant :

(function () {
  return DYO.Q.Promise(function (resolve, reject) {
    var GCG_STORAGE_NAME = '_dy_cs_gcg';
    var STORAGE_TYPE = 'cookieStorage';
    window.DY.CS = window.DY.CS || {};
    if (window.DY.CS.inGlobalControl) {
      resolve(window.DY.CS.inGlobalControl);
      return true;
    }

    getGCCookie();

    function getGCCookie() {
      var GCValue = window.DYO.StorageUtils.get(GCG_STORAGE_NAME, [STORAGE_TYPE]);
      if (GCValue) {
        window.DY.CS.inGlobalControl = GCValue;
        resolve(GCValue);
      } else {
        setTimeout(function () {
          getGCCookie();
        }, 50);
      }
    }
  });
})();

5. Sauvegardez l’évaluateur.

Étape 2 : Cibler vos expériences sur l’évaluateur

Étape 3 : Établir des rapports pour le GCG

Si vous optez pour l’option B : faites une demande d’API pour le GCG avant de faire d’autres demandes d’API pour l’allocation du GCG, vous utiliserez l’expérience créée pour l’allocation dans votre rapport sur le test de contrôle global, et aucune autre étape n’est donc nécessaire.

Toutefois, si vous optez pour l’option A recommandée : déterminez l’allocation dans votre base de code et transmettez-la à Dynamic Yield, créez une campagne API personnalisée à l’aide des paramètres suivants afin de configurer la création de rapports pour votre test GCG :

1. Nommez la campagne « Test de contrôle global ».
2. Créez une expérience appelée Dynamic Yield Experiences.
   1. Ciblez cette expérience à l’aide de l’attribut personnalisé Dynamic Yield Experience.
   2. Ajoutez une variation avec une allocation de trafic de 100 % contenant le code JSON suivant :

{ "Dynamic Yield Experiences" : "true" }

3. Créez une deuxième expérience portant le nom « Groupe témoin ».
   1. Ciblez cette expérience à l’aide de l’attribut personnalisé Groupe témoin.
   2. Ajoutez une variation avec une allocation de 100 % du trafic contenant le code JSON suivant :

{"Control" : "true" }

4. Publiez-la.
5. Veillez à appeler cette campagne API au moins une fois par session pour chaque utilisateur. Vous n’avez pas besoin d’utiliser la réponse de cet appel pour quoi que ce soit, il est appelé pour enregistrer une impression pour cette campagne afin qu’il y ait un suivi de la performance globale du GCG.