Guia de Grupo de Controle Global para Seções usando Campanhas por API

O teste de controle global é um método para medir o impacto geral do seu programa de experimentação. A medida é feita usando-se um teste A/B que divide seu tráfego geral em dois grupos – usuários que recebem experiências personalizadas da Dynamic Yield e os que não recebem – e os compara. Este último grupo é o grupo de controle global, ou GCG.

Este artigo descreve diversas opções para implementar o GCG em campanhas por API. Converse com a sua equipe de conta sobre quais fazem sentido para você.

Configurar um GCG exige os seguintes passos:

Passo 1: alocar usuários ao GCG

Passo 2: adicionar experiências ao GCG

Passo 3: configurar os relatórios para o GCG

Passo 1: alocar usuários ao grupo de controle global

Há duas opções para atribuir usuários ao controle global ou ao grupo de experiências da Dynamic Yield.

Opção A: determinar a alocação em sua base de código e passá-la para a Dynamic Yield (recomendado)

1. Implemente o código como nos exemplos a seguir dentro da sua base de código, de modo que ele seja executado antes da primeira solicitação de API para o terminal Choose da Dynamic Yield. Verifique se o usuário já possui o cookie "_dy_cs_gcg", e se não possuir, decida qual versão do GCG ele receberá.

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) { // se um valor gcg já existir
    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, { // armazene um novo cookie de valor gcg
      expires: new Date(Date.now() + 31540000000000), // defina validade de 1 ano para o novo cookie
    });
  
  next();
});

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

<?php declare(strict_types=1);

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

    /**
     * Tipo de grupo
     */
    protected $_groupType = null;

    /**
     * Obter tipo de grupo do usuário
     * @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:
        # CHAMADA PARA CAMPANHAS POR API DA DY

2. Use o valor de gcValue na opção pageAttributes de todas as suas solicitações choose para dizer à Dynamic Yield se esse usuário deve ser colocado no grupo de controle ou no grupo 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. Em sua resposta ao navegador, defina o valor correto do cookie "_dy_cs_gcg" como um cabeçalho de resposta, com uma data de expiração de 1 ano, conforme mostrado no exemplo em NodeJS. Esse cookie poderá, por fim, ser usado para quaisquer experiências do lado do cliente que você planejar adicionar ao GCG (consulte adicionar experiências do lado do cliente ao GCG).

Opção B: fazer uma solicitação de API para o GCG antes de fazer outras solicitações de API

Essa opção é menos simplificada, pois exige duas chamadas de API separadas para a Dynamic Yield para novos usuários, antes da renderização.

1. Crie uma nova campanha personalizada por API e nomeie-a Global Control Test.
2. Crie uma experiência com o nome Global Control Test;
3. Crie uma variação chamada Dynamic Yield Experiences com o seguinte JSON:

{"_dy_cs_gcg":"Dynamic Yield Experiences"}

4. Crie outra variação chamada Control Group com o seguinte JSON:

{ "_dy_cs_gcg" : "Control" }

5. Defina a alocação como 95% para o Dynamic Yield Experiences e 5% para o grupo de controle.
6. Publique a campanha.
7. Com a primeira visualização de página, verifique se o usuário já possui o cookie "_dy_cs_gcg", e se não possuir, faça uma solicitação de API apenas para a campanha Global Control Test. Use o valor de "_dy_cs_gcg" na opção pageAttributes da solicitação choose para as campanhas restantes na página.
8. Em sua resposta ao navegador, defina o valor correto do cookie "_dy_cs_gcg" como um cabeçalho de resposta, com uma data de expiração de 1 ano. Esse cookie poderá, por fim, ser usado por quaisquer experiências do lado do cliente que você planejar adicionar ao GCG (consulte adicionar experiências do lado do cliente ao GCG).

Passo 2: adicionar experiências ao GCG

Adicionar uma experiência ao GCG é diferente, dependendo se é uma experiência por API ou script. 

Experiências por API

Vá até a experiência por API que você deseja adicionar ao teste de controle global e use a condição de direcionamento Custom Attribute (atributo personalizado) para direcioná-la ao grupo Dynamic Yield Experiences.

Experiências do lado do cliente

Passo 1: crie o avaliador

O avaliador é usado para direcionar experiências para o grupo Dynamic Yield Experiences ou para o grupo de controle.

1. Crie um avaliador com o nome Global Control Test Group.

2. Defina o tipo de valor como String.

3. Defina Expected Values (valores esperados) como Dynamic Yield Experiences e Control Group.

4. Insira o código:

(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. Salve o avaliador.

Passo 2: direcione suas experiências para o avaliador

Passo 3: configure os relatórios para o GCG

Se decidir pela Opção B: fazer uma solicitação de API para o GCG antes de fazer outras solicitações de API para alocação do GCG, você usará a experiência criada para alocação para os seus relatórios no teste de controle global, portanto nenhum outro passo será necessário.

No entanto, se você escolher a recomendada Opção A: determinar a alocação em sua base de código e passá-la para a Dynamic Yield, crie uma campanha Custom API (API personalizada) usando as seguintes configurações para preparar os relatórios para o seu teste de GCG:

1. Nomeie a campanha como Global Control Test.
2. Crie uma experiência com o nome Dynamic Yield Experiences.
   1. Direcione essa experiência usando o Custom Attribute para o Dynamic Yield Experiences.
   2. Adicione uma variação com 100% de alocação de tráfego contendo o seguinte código JSON:

{ "Dynamic Yield Experiences" : "true" }

3. Crie uma segunda experiência com o nome Control Group.
   1. Direcione essa experiência usando o Custom Attribute para o Control Group.
   2. Adicione uma variação com 100% de alocação de tráfego contendo o seguinte código JSON:

{"Control" : "true" }

4. Publique-a.
5. Certifique-se de chamar essa campanha por API pelo menos uma vez por sessão para cada usuário. Você não precisa usar a resposta dessa chamada para nada. Ele é chamada para registrar uma impressão para essa campanha, de modo que haja rastreamento do desempenho geral do GCG.