Guida ai gruppi di controllo globale per le sezioni con (solo) campagne incentrate sulle API

Il test di controllo globale è un metodo per misurare l'impatto complessivo del tuo programma di sperimentazione. La misurazione si esegue tramite un test A/B che dividerà il tuo traffico complessivo in due gruppi (chi visualizzerà un'esperienza personalizzata Dynamic Yield e chi no) e li compara. Quest'ultimo gruppo è il gruppo di controllo globale o "global control group" (GCG).

Questo articolo descrive diverse opzioni per l'implementazione del GCG nelle campagne API. Discuti con il team che gestisce il tuo account quali hanno senso per te.

L'impostazione di un GCG richiede i seguenti passaggi:

Passaggio 1: assegna gli utenti al GCG

Passaggio 2: aggiungi esperienze al GCG

Passaggio 3: configura la creazione dei report per il GCG

Passaggio 1: assegna gli utenti al gruppo di controllo globale

Sono disponibili due opzioni per l'assegnazione degli utenti al gruppo di controllo globale o al gruppo delle esperienze Dynamic Yield.

Opzione A: determina l'allocazione nella codebase e passala a Dynamic Yield (raccomandato)

1. Implementa il codice come negli esempi seguenti all'interno della codebase di modo che venga eseguito prima della prima richiesta API all'endpoint scelta Dynamic Yield. Controlla se l'utente dispone già del cookie "_dy_cs_gcg" e, in caso contrario, valuta quale versione di GCG gli proporrai.

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) { // if a gcg value already exists
    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, { // store a new gcg value cookie
      expires: new Date(Date.now() + 31540000000000), // Set a 1 year expiration for the new cookie
    });
  
  next();
});

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

<?php declare(strict_types=1);

class GroupType
{
    /**
     * Cookie name
     */
    protected $_cookieName = '_dy_cs_gcg';

    /**
     * Group type
     */
    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. Usa il valore di gcValue nell'opzione pageAttributes di tutte le tue richieste di scelta per indicare a Dynamic Yield se l'utente deve essere inserito nel gruppo di controllo o nel gruppo delle esperienze Dynamic Yield. 

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. Nella risposta al browser, imposta il valore corretto per "_dy_cs_gcg" come intestazione della risposta con una data di scadenza di 1 anno, come mostrato nell'esempio su NodeJS. Questo cookie si può usare per qualsiasi esperienza lato client che si prevede di aggiungere al GCG (consulta la sezione Aggiunta di esperienze lato client al GCG).

Opzione B: effettua una richiesta API per il GCG prima di effettuare altre richieste API

Questa opzione è meno semplice, in quanto richiede due chiamate API separate a Dynamic Yield per i nuovi utenti prima del rendering.

1. Crea una nuova campagna API personalizzata e assegnale il nome Global Control Test.
2. Crea un'esperienza con il nome Global Control Test.
3. Crea una variante chiamata Dynamic Yield Experiences con il seguente codice JSON:

{"_dy_cs_gcg":"Dynamic Yield Experiences"}

4. Crea un'altra variante chiamata Control Group con il seguente JSON:

{ "_dy_cs_gcg" : "Control" }

5. Imposta l'allocazione al 95% per le esperienze Dynamic Yield e al 5% per il gruppo di controllo.
6. Pubblica la campagna.
7. Alla prima visualizzazione di pagina, verifica se l'utente dispone già del cookie "_dy_cs_gcg" e, in caso contrario, effettua una richiesta API solo per la campagna di test del gruppo di controllo globale. Usa il valore "_dy_cs_gcg" nell'opzione pageAttributes tra le scelte richieste per le restanti campagne della pagina.
8. Nella risposta al browser, imposta il valore corretto per il cookie "_dy_cs_gcg" come intestazione della risposta con una data di scadenza di 1 anno. Questo cookie si può eventualmente usare per tutte le esperienze lato client che si prevede di aggiungere al GCG (consulta la sezione Aggiunta di esperienze lato client al GCG).

Passaggio 2: aggiungi esperienze al GCG

L'aggiunta di un'esperienza al GCG è diversa a seconda che si tratti di un'esperienza API o con script. 

Esperienze API

Vai all'esperienza API che desideri aggiungere al test di controllo globale e utilizza la condizione di targeting degli attributi personalizzati per indirizzarla al gruppo delle esperienze Dynamic Yield.

Esperienze lato client

Passaggio 1: crea l'analizzatore

L'analizzatore si usa per indirizzare le esperienze al gruppo delle esperienze Dynamic Yield o al gruppo di controllo.

1. Crea un analizzatore denominato Global Control Test Group.

2. Imposta il tipo di valore su String.

3. Imposta i valori attesi su Dynamic Yield Experiences e Control Group.

4. Inserisci il codice:

(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. Salva l'analizzatore.

Passaggio 2: indirizza le tue esperienze all'analizzatore

Passaggio 3: configura la creazione di report per il GCG

Se deciderai di optare per l'opzione B, puoi effettuare una richiesta API per il GCG prima di effettuare altre richieste API per l'allocazione del GCG, tramite l'esperienza creata per l'allocazione per il reporting sul test di controllo globale e non saranno necessari altri passaggi.

Tuttavia, se dovessi scegliere il metodo consigliato, ossia l'opzione A, potrai determinare l'allocazione nella codebase e passarla a Dynamic Yield, creando una campagna API personalizzata utilizzando le seguenti impostazioni per impostare i rapporti per il tuo test sul GCG:

1. Nome della campagna Global Control Test.
2. Crea un'esperienza con il nome Dynamic Yield Experiences.
   1. Indirizza questa esperienza usando l'attributo personalizzato come Dynamic Yield Experiences.
   2. Aggiungi una variante con allocazione del traffico al 100% contenente il seguente codice JSON:

{ "Dynamic Yield Experiences" : "true" }

3. Crea una seconda esperienza con il nome Control Group.
   1. Indirizza questa esperienza usando l'attributo personalizzato come Control Group.
   2. Aggiungi una variante con allocazione del traffico al 100% contenente il seguente codice JSON:

{"Control" : "true" }

4. Pubblica il tutto.
5. Assicurati di impostare una chiamata a questa campagna API almeno una volta per sessione per ogni utente. Non dovrai utilizzare la risposta di questa chiamata per altro, se non come chiamata per registrare un'impressione per questa campagna in modo che ci sia il monitoraggio per le prestazioni complessive del GCG.