# Object cache no WordPress: medir carrinho e wp-admin logados

Como medir a URL autenticada com o cookie de sessão real, confirmar o hit no Redis e desligar o drop-in sem deixar chave velha presa no backend.

> por padrão, requisição com cookie de sessão não é servida do cache de página (só se você configurar o cache para logados explicitamente), então carrinho, checkout e wp-admin dependem do object cache persistente. O guia mostra como medir a URL logada com curl e provar o hit.

João Rizzon · 2026-09-22 · WordPress

---

## Por que o cache de página termina no cookie de sessão

Cache de página de disco, seja LiteSpeed Cache, FastCGI cache ou proxy na frente, tem uma regra que aparece em todas as configurações padrão: requisição com cookie de sessão não é servida do cache e normalmente também não é gravada nele. Alguns stacks permitem cachear usuário logado por configuração explícita (LiteSpeed Cache tem opção para isso, e em proxy dá para variar a chave pelo cookie), mas é opt-in e traz risco de servir conteúdo de uma sessão para outra. No WordPress isso significa qualquer request que carregue `wordpress_logged_in_*`. No WooCommerce, também `wp_woocommerce_session_*`, `woocommerce_items_in_cart` e `woocommerce_cart_hash`. E o `/wp-admin/` não depende de regra nenhuma para ficar de fora: o core chama `nocache_headers()`, cuja lista base é `Cache-Control: no-cache, must-revalidate, max-age=0`, e no admin um filtro sobre `nocache_headers` acrescenta `no-store, private`, de modo que a resposta autenticada sai com `no-cache, must-revalidate, max-age=0, no-store, private`. A string sem `no-store, private` é a do front-end.

Consequência prática: todo trabalho de PHP e de MySQL que o cache de página escondia do visitante anônimo continua inteiro na requisição autenticada. Carrinho, checkout, `/minha-conta/`, área de membros, listagem de posts no admin. Nessas URLs o que sobra para otimizar é o custo interno da geração: número de queries, custo de cada query e chamadas HTTP externas durante o render.

O object cache ataca a primeira parte. A API `wp_cache_get()` / `wp_cache_set()` existe sempre, mas sem drop-in ela é um array em memória do processo PHP, jogado fora no fim da requisição. Colocar um arquivo `wp-content/object-cache.php` apontando para Redis ou Memcached troca esse array por um backend que sobrevive entre requisições. A partir daí, `alloptions`, `posts`, `terms`, `usermeta` e transients passam a vir de fora do MySQL, desde que o grupo da chave seja persistente (voltaremos a isso).

O que quase nenhum tutorial de plugin entrega é a parte chata: medir a URL logada com o cookie real, provar que o hit está acontecendo e saber desligar sem deixar lixo preso no backend.

## Medir a mesma URL logada antes e depois do drop-in

Medição sem cookie mede outra coisa. Se você aponta o `curl` para `/checkout/` sem sessão, recebe redirect ou página vazia, e o TTFB resultante não tem relação com o que o cliente logado espera. O procedimento abaixo usa uma sessão de verdade.

### Criar um usuário de teste com a menor capability

Não faça login com a sua conta de administrador nesse laço. Crie um usuário dedicado, com a menor capability que ainda alcance a URL medida, e descarte depois. Para URLs de loja, um `customer`. Para `/wp-admin/edit.php`, um `editor`.

```bash
wp user create medidor medidor@exemplo.test --role=editor --user_pass="$(openssl rand -base64 24)"
```

Guarde a senha em arquivo sem newline final, para não acabar enviando `%0A` junto:

```bash
umask 077
printf '%s' 'a-senha-gerada' > /tmp/pwd.txt
```

### Obter um cookie de sessão real com curl e testcookie

O `wp-login.php` valida o `wordpress_test_cookie` quando o POST inclui `testcookie=1`. Por isso são duas requisições: um GET para receber o test cookie e o POST na mesma jar.

```bash
JAR=$(mktemp); BASE=https://exemplo.com.br

curl -s -c "$JAR" -b "$JAR" -o /dev/null "$BASE/wp-login.php"

curl -s -c "$JAR" -b "$JAR" -o /dev/null -L \
  --data-urlencode "log=medidor" \
  --data-urlencode "pwd@/tmp/pwd.txt" \
  -d "wp-submit=Acessar&testcookie=1&redirect_to=$BASE/wp-admin/" \
  "$BASE/wp-login.php"

grep -c wordpress_logged_in "$JAR"
```

Se o `grep` retornar `0`, o login falhou e não há o que medir. Causas comuns: senha com newline, `testcookie` ausente, plugin de 2FA no caminho, ou WAF bloqueando POST sem `User-Agent` de navegador (acrescente `-A`).

Para medir carrinho com item dentro, o cookie de login não basta: precisa da sessão do WooCommerce. O parâmetro GET de adicionar ao carrinho resolve isso na mesma jar.

```bash
curl -s -c "$JAR" -b "$JAR" -o /dev/null -L "$BASE/?add-to-cart=123"
grep -c wp_woocommerce_session "$JAR"
```

### O que o time_starttransfer mede e o que subtrair dele

`%{time_starttransfer}` é o tempo desde o início da chamada do curl até o primeiro byte do corpo estar chegando. Inclui DNS, TCP, TLS e envio da requisição. Se você comparar duas medições feitas de redes diferentes, a diferença pode ser handshake, não PHP. Para isolar a espera do servidor, subtraia `%{time_pretransfer}`, que marca o instante em que o curl terminou de preparar e começou a transferir.

```bash
curl -s -o /dev/null -b "$JAR" \
  -w 'dns=%{time_namelookup} tls=%{time_appconnect} pre=%{time_pretransfer} ttfb=%{time_starttransfer} total=%{time_total}\n' \
  "$BASE/wp-admin/edit.php?post_type=post"
```

### Repetir 25 vezes e usar a mediana, não a média

Uma amostra única em ambiente compartilhado não diz nada. Rode um número ímpar de repetições e use a mediana, que resiste melhor a um outlier de vizinhança do que a média. Vinte e cinco repetições é um ponto de partida razoável para uma URL de admin.

```bash
for i in $(seq 1 25); do
  curl -s -o /dev/null -b "$JAR" -H 'Accept-Encoding: gzip' \
    -w '%{time_pretransfer} %{time_starttransfer}\n' \
    "$BASE/wp-admin/edit.php?post_type=post"
  sleep 1
done | awk '{printf "%.4f\n", $2-$1}' | sort -n \
     | awk '{v[NR]=$1} END {print "mediana(s):", v[int((NR+1)/2)]}'
```

O `sleep 1` existe para não medir 25 requisições empilhadas no mesmo PHP-FPM e confundir enfileiramento com tempo de geração. Guarde a saída bruta de cada rodada em arquivo, não só a mediana: a dispersão é informação. Depois de ligar o drop-in, rode o mesmo laço, com a mesma jar recém-renovada, na mesma URL, no mesmo horário do dia.

Armadilhas que invalidam a comparação: primeira requisição depois de um deploy (OPcache frio), `wp-cron.php` disparado dentro da requisição medida, e URL de admin que faz chamada HTTP externa (atualizações, licenças) em intervalos próprios.

## Ligar o drop-in sem colidir chave entre instalações

O plugin de Redis ou Memcached é só o instalador e a interface. O que funciona é o arquivo `wp-content/object-cache.php`. Verifique o que está ativo com:

```bash
wp cache type
wp redis status   # disponível quando o drop-in de Redis é o do plugin Redis Object Cache
```

Em servidor cPanel, a [documentação oficial da cPanel descreve o Redis rodando como container por usuário](https://docs.cpanel.net/ea4/containers/redis-via-containers/), com host e porta atribuídos ao container, em vez de um serviço único do sistema. Consulte essa página para os comandos e requisitos exatos da sua versão e pegue de lá o endpoint. Você também precisa da extensão PHP correspondente na versão de PHP que o site usa: confirme com `php -m | grep -i redis` executado com o binário certo, não com o PHP padrão do shell.

A parte que morde: **duas instalações WordPress no mesmo banco Redis, sem prefixo distinto, escrevem na mesma chave**. `alloptions` do site A sobrescreve `alloptions` do site B, e o sintoma é opção que "volta" sozinha. Separe por índice de banco (o Redis expõe 16 por padrão) ou, melhor, por prefixo, que também deixa o flush seletivo viável.

| Constante em `wp-config.php` | Papel | Cuidado |
|---|---|---||
| `WP_REDIS_HOST`, `WP_REDIS_PORT` | endpoint TCP do backend | em container por usuário, a porta é a do seu container |
| `WP_REDIS_SCHEME`, `WP_REDIS_PATH` | conexão por socket unix | só se o socket estiver acessível ao usuário do PHP |
| `WP_REDIS_DATABASE` | índice do banco | isola, mas não evita `FLUSHALL` de terceiros |
| `WP_REDIS_PREFIX` / `WP_CACHE_KEY_SALT` | prefixo das chaves | único por instalação, inclusive entre staging e produção |
| `WP_REDIS_MAXTTL` | TTL máximo aplicado às chaves | evita chave sem expiração acumulando para sempre |
| `WP_REDIS_DISABLED` | desliga o drop-in sem removê-lo | útil para A/B rápido na medição |

Os nomes acima são os do drop-in de Redis mais difundido. Confirme no README da versão que você instalou, porque drop-ins alternativos usam outros nomes. Para Memcached, o equivalente é o array `$memcached_servers` e um salt de chave.

Staging e produção apontando para o mesmo Redis, com o mesmo prefixo, é a receita para debugar por três horas um bug que não existe.

## Provar o hit com INFO stats, SAVEQUERIES e Query Monitor

TTFB menor é indício, não prova. Três verificações independentes:

**Do lado do Redis.** `keyspace_hits` e `keyspace_misses` em `INFO stats` são contadores globais do servidor, cumulativos desde o start. Meça a diferença em volta de uma requisição, não o valor absoluto.

```bash
redis-cli -h 127.0.0.1 -p PORTA INFO stats | grep -E 'keyspace_(hits|misses)|evicted_keys'
redis-cli -h 127.0.0.1 -p PORTA INFO keyspace
redis-cli -h 127.0.0.1 -p PORTA --scan --pattern 'SEU_PREFIXO*' | head -20
```

`INFO keyspace` mostra quantas chaves existem por índice de banco e quantas têm expiração. Banco vazio depois de dez requisições logadas significa que o drop-in não está conectando, e provavelmente falhando em silêncio. `MONITOR` responde na hora se há tráfego, mas custa caro: use por segundos, nunca deixe rodando.

**Do lado do WordPress.** Contagem de queries por requisição é o número que importa. Ligue `SAVEQUERIES` temporariamente e registre o resultado em log, porque no admin não há saída limpa para ler:

```php
<?php
// wp-content/mu-plugins/zz-qcount.php  (exemplo, remover depois da medição)
add_action( 'shutdown', function () {
    global $wpdb, $wp_object_cache;
    $n = ( defined( 'SAVEQUERIES' ) && SAVEQUERIES && isset( $wpdb->queries ) )
        ? count( $wpdb->queries ) : -1;
    $hits   = isset( $wp_object_cache->cache_hits )   ? $wp_object_cache->cache_hits   : -1;
    $misses = isset( $wp_object_cache->cache_misses ) ? $wp_object_cache->cache_misses : -1;
    error_log( sprintf(
        '[qcount] uri=%s queries=%d oc_hits=%d oc_misses=%d',
        isset( $_SERVER['REQUEST_URI'] ) ? $_SERVER['REQUEST_URI'] : '-',
        $n, $hits, $misses
    ) );
}, PHP_INT_MAX );
```

`SAVEQUERIES` guarda todas as queries em memória e tem custo próprio: não deixe ligado em produção depois da medição, e compare sempre queries com queries (com `SAVEQUERIES` ligado nas duas rodadas), nunca queries de uma rodada contra TTFB da outra.

**Interativamente.** O Query Monitor mostra o painel de object cache com tipo do backend e razão de hits, além de queries agrupadas por componente, que é como você descobre que 60 das queries vêm de um plugin específico e não do core.

## Os grupos que continuam indo ao MySQL mesmo com Redis

O drop-in não persiste tudo. Existem grupos marcados como non-persistent, e chave nesses grupos vive só na requisição, exatamente como antes. O core chama `wp_cache_add_non_persistent_groups()` durante o boot com grupos como `counts` e `plugins`; a lista exata muda entre versões, então confirme na sua olhando `wp-includes/load.php`. Drop-ins somam a própria lista de grupos ignorados, e plugins podem acrescentar mais em runtime.

Isso explica um resultado que frustra: contagem de posts por status no admin, por exemplo, tende a continuar consultando o banco. Se a sua URL lenta é exatamente uma dessas, o object cache não vai resolver e o caminho é índice, query ou menos dados.

Outras coisas que continuam no MySQL por desenho:

- **Sessões do WooCommerce** ficam na tabela `wp_woocommerce_sessions`, com limpeza por evento agendado. Sessão não é object cache.
- **Carrinho e checkout** executam lógica de cálculo, taxas e frete a cada requisição, inclusive chamadas a transportadora por HTTP.
- **`autoload` inflado em `wp_options`** continua sendo lido a cada boot. Com object cache ele vira uma chave gigante (`alloptions`) que é serializada e trafegada inteira em cada requisição, o que pode piorar em vez de melhorar. Meça o tamanho:

```sql
SELECT COUNT(*) AS n, ROUND(SUM(LENGTH(option_value))/1024) AS kb
FROM wp_options
WHERE autoload IN ('yes','on','auto','auto-on');
```

O `WHERE` acima cobre as duas convenções: até o WP 6.5 o campo era `yes`/`no`; da 6.6 em diante passou a aceitar também `on`, `off` e variantes `auto`. Ajuste ao seu esquema.

- **Transients passam a viver no backend** quando existe object cache persistente. Isso é ganho de escrita no banco e, ao mesmo tempo, o risco da próxima seção.

## maxmemory, eviction e o transient que some em silêncio

Sem `maxmemory` configurado, a política de eviction é irrelevante e o que limita é a memória do host ou do container, com OOM kill no final. Com `maxmemory` definido, a política decide o que acontece quando enche.

| Política | Comportamento ao encher | Efeito no WordPress |
|---|---|---||
| `noeviction` | grava falha com erro OOM | drop-in registra erro; o site segue, mas sem cache novo |
| `allkeys-lru` | remove qualquer chave, inclusive sem TTL | transient desaparece antes da hora, em silêncio |
| `volatile-lru` | remove só chaves com TTL | chave sem expiração nunca sai e pode travar o espaço |

O caso perigoso é `allkeys-lru` num Redis compartilhado com outra finalidade. Com object cache persistente ligado, `set_transient()` grava no Redis, não em `wp_options`. Código que usa transient como lock, como marcador de "já rodou hoje" ou como cache de resposta de API externa passa a depender de uma chave que o eviction pode apagar a qualquer momento. Não há erro, não há log: só trabalho repetido e, no caso de lock, execução concorrente que não deveria existir.

Instância dedicada a cache com `allkeys-lru` é escolha defensável, desde que você olhe `evicted_keys` e a razão hits/misses de vez em quando. O que não é defensável é assumir durabilidade de transient em cima de LRU. Se o Redis roda como container por usuário, a política é do seu container, e o que você pode ajustar depende do que a documentação da plataforma expõe.

Teste também a queda: derrube o backend em staging e recarregue uma URL logada. Drop-in moderno tende a degradar para o array por requisição, mas há versões e configurações em que a falha vira erro 500. Descobrir isso em staging é barato.

## Reverter na ordem certa para não deixar chave órfã

A ordem importa. Remover o drop-in primeiro e esvaziar depois deixa chaves órfãs no backend que voltam a ser lidas no dia em que você religar, com dados de semanas atrás.

### Esvaziar o cache antes de desligar o drop-in

```bash
wp cache flush
```

Atenção: com alguns drop-ins de Redis, `wp cache flush` executa `FLUSHDB` no banco configurado, o que apaga também as chaves de qualquer outra aplicação que compartilhe aquele índice. É a razão de existir prefixo e índice dedicados por instalação. Se houver vizinho no mesmo banco, apague por prefixo com `--scan` e `DEL`, em lotes, em vez de dar flush.

### Mover o object-cache.php para fora da raiz web

Em hospedagem compartilhada você não escreve fora do seu home, então guarde o backup dentro dele:

```bash
mkdir -p ~/backups
mv wp-content/object-cache.php ~/backups/object-cache.php.bak-$(date +%F)
```

Mover, não deletar. Se o rollback der errado, você quer o arquivo exato de volta, inclusive a versão dele. Confirme que o destino está fora da raiz web: `~/backups` só é seguro se não for servido por nenhum domínio ou subdomínio do seu cPanel.

### Confirmar que o fallback em memória voltou

```bash
wp cache type            # deve indicar o cache padrão do core
wp redis status          # deve reportar que não está conectado
redis-cli -h 127.0.0.1 -p PORTA --scan --pattern 'SEU_PREFIXO*' | head
```

O `--scan` não deve listar chave nova depois de algumas requisições. Se listar, sobrou drop-in em outro lugar (multisite, `WP_CONTENT_DIR` customizado) ou um plugin reinstalou o arquivo.

### Confirmar que os transients voltaram para wp_options

```sql
SELECT COUNT(*) FROM wp_options WHERE option_name LIKE '\_transient\_%';
```

Rode antes e depois de navegar pelo site. O contador precisa voltar a crescer: é a prova de que a camada de transients está de novo em `wp_options`. Os transients que estavam no Redis se perdem no flush, e aqui vale a distinção da seção de eviction: transient que guarda dado derivado (resposta de API, HTML de widget, contagem) é recuperável por definição, porque será recalculado no próximo acesso. Transient usado como lock, como semáforo de rotina única ou como marcador de "já rodou hoje" não é: apagá-lo libera a reexecução de algo que deveria rodar uma vez só. Antes do flush, faça um `--scan` pelo prefixo procurando chaves com nome de lock (`*_lock`, `*_running`, `*_doing_*`) e decida caso a caso se o job pode rodar de novo naquele instante. Em loja com integração fiscal ou de estoque, faça a reversão em janela de baixo movimento. Depois, limpe o que expirou:

```bash
wp transient delete --expired
```

### Repetir a medição para fechar o ciclo da reversão

Mesma URL, mesma jar de cookie renovada, mesmas 25 repetições. Reversão sem medição de volta não fecha o ciclo: você fica sem saber se o problema era o object cache ou se o ganho que você atribuiu a ele veio de outra mudança feita no mesmo dia.

## Quando o gargalo não é o object cache e onde olhar

Vale dizer antes de você instalar qualquer coisa: se a mediana da URL logada não melhora com o drop-in ligado, o gargalo está em outro lugar, e trocar de plano provavelmente não muda nada.

Onde olhar, em ordem de retorno:

- **Log de query lenta.** Ligue `slow_query_log` com `long_query_time` baixo por um intervalo curto, gere tráfego logado na URL e leia. Query de 2 segundos em `wp_postmeta` sem índice não é problema de cache.
- **Contagem de queries por componente.** Query Monitor agrupa por plugin. Plugin que faz 400 queries no admin é bug de plugin.
- **Chamadas HTTP externas no render.** Filtre `pre_http_request` temporariamente para logar cada request de saída com o tempo. API externa lenta dentro do checkout aparece como TTFB alto e some do radar de qualquer cache.
- **`autoload` de `wp_options`.** Query da seção anterior. Centenas de KB carregadas a cada boot pesam com ou sem Redis.
- **Heartbeat e `wp-cron`.** No admin, `admin-ajax.php?action=heartbeat` e cron disparado em requisição de visitante competem por worker de PHP-FPM. Mover o cron para agendamento de sistema com `DISABLE_WP_CRON` é mudança de uma linha.

O object cache persistente resolve um tipo específico de desperdício: leitura repetida da mesma opção, do mesmo post, do mesmo meta, dentro e entre requisições. Quando é isso, o efeito aparece na contagem de queries antes de aparecer no TTFB. Quando a contagem de queries não cai, o drop-in não é a resposta, e o mais honesto é desinstalar seguindo a seção anterior e voltar ao log de query lenta.

