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.

Resposta curta: 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.
Neste artigo
- Por que o cache de página termina no cookie de sessão
- Medir a mesma URL logada antes e depois do drop-in
- Ligar o drop-in sem colidir chave entre instalações
- Provar o hit com INFO stats, SAVEQUERIES e Query Monitor
- Os grupos que continuam indo ao MySQL mesmo com Redis
- maxmemory, eviction e o transient que some em silêncio
- Reverter na ordem certa para não deixar chave órfã
- Quando o gargalo não é o object cache e onde olhar
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.
wp user create medidor [email protected] --role=editor --user_pass="$(openssl rand -base64 24)"
Guarde a senha em arquivo sem newline final, para não acabar enviando %0A junto:
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.
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.
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.
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.
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:
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, 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.
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
// 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.
autoloadinflado emwp_optionscontinua 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:
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
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:
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
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
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:
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_logcomlong_query_timebaixo por um intervalo curto, gere tráfego logado na URL e leia. Query de 2 segundos emwp_postmetasem í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_requesttemporariamente 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. autoloaddewp_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=heartbeate cron disparado em requisição de visitante competem por worker de PHP-FPM. Mover o cron para agendamento de sistema comDISABLE_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.
Referências
- Documentação oficial (cpanel) — Redis via Containers. Consultado em 2026-09-20.