Backend WordPress lento? Encontre funções PHP lentas com o phpspy
À espera ou a computar, o plugin e a função responsáveis, e como provar que o fix tornou o backend mais rápido.
- Bom ≤ 0,8 s
- Precisa de melhorias ≤ 1,8 s
- Mau > 1,8 s
Partilhar
Um backend WordPress lento em resumo
Um backend WordPress lento nota-se nas páginas que a cache de página não consegue servir: membros com sessão iniciada, wp-admin, pesquisa. O PHP constrói-as a cada request. Um request lento fica à espera da base de dados ou de um serviço externo, ou a executar código PHP. No nosso site de testes, três plugins atrasaram a página de curso de um membro de 32 para 793 ms; o phpspy, um profiler de PHP para servidores em produção, identificou cada um.
Porque é que o backend do WordPress é lento quando as páginas em cache são rápidas?
As páginas do WordPress em cache são rápidas porque a cache de página entrega aos visitantes sem sessão iniciada uma cópia guardada anteriormente. Membros com sessão iniciada, wp-admin, resultados de pesquisa e carrinhos ignoram essa cópia: o PHP constrói a página para esse request, por isso todos os plugins lentos correm sempre.
O site de testes é a Acme Academy, uma escola online de marcenaria em WordPress, a correr numa VM Ubuntu num Mac mini com nginx, PHP-FPM 8.4 e OPcache, e medida com curl a partir do Mac. A respetiva página de curso é servida pela cache de página em 15 ms. Ultrapassada a cache, a mesma página demora 683 ms para um visitante sem sessão iniciada e 793 ms para um membro.
A administração do WordPress (wp-admin) é lenta porque as suas páginas nunca são guardadas em cache: o código de administração de cada plugin corre a cada carregamento. No site de testes, o dashboard do instrutor demorou 398 ms, e 355 ms desse tempo foram gastos por um widget do dashboard a pedir a próxima sessão em direto a um serviço externo.
Nos field data, isto corresponde à parte do request no TTFB e destaca-se assim que o segmenta pelo estado da sessão: identificar e corrigir um TTFB lento mostra como fazê-lo, e o guia de duração do request inclui o código da cache de página e de Server-Timing.
O que torna um request PHP lento?
Um request PHP lento ou está à espera ou a computar. Ficar à espera é o PHP estar parado numa query à base de dados ou numa chamada HTTP externa. Computar é o PHP a executar código, ou a compilá-lo primeiro se o OPcache estiver desativado. Uma espera aponta para o código que a pediu; a computação aponta para a própria função. Um profiler de PHP mostra qual é o caso: na página de curso do site de testes, o phpspy encontrou 45% das amostras à espera de uma chamada externa, 47% da base de dados e 9% a executar código PHP.
O site de testes tem cinco partes lentas, cada uma resultante de uma causa descrita na documentação do WordPress, no Trac do core ou no manual do PHP. Os ganhos são medianas na página de curso do membro ao longo de 30 rondas com e sem cada fix.
- A chamada externa. Uma caixa "Next live session" chama uma API de agendamento a cada visualização, e a API demora 350 ms a responder, o que acrescenta 401 ms à página de curso, 393 ms à página de lição e 355 ms ao dashboard. No perfil, isto é uma espera em
curl_execsobacme_fetch_sessions, e o fix guarda a resposta num transient que o WP-Cron atualiza. - A pesquisa em
meta_value(lookup). "More courses by this instructor" pesquisa emmeta_value, uma coluna sem índice, numa tabela postmeta com 903 362 linhas, e acrescenta 277 ms enquanto o PHP espera emmysqli_querysobacme_more_by_instructor. Uma taxonomia de instrutores e umatax_queryresolvem o problema. - A caixa de progresso. A secção "Your progress" faz o parse e o render de 600 lições com
parse_blocks()erender_block()a cada request, o que acrescenta 125 ms (104 ms na página de lição). O perfil mostra frames de PHP sobacme_build_progresssem qualquer espera no topo; guarde o resumo no user meta e reconstrua-o quando uma lição for concluída. - A opção com autoload. Uma opção com autoload de 2,6 MB não fez qualquer diferença mensurável, 54 contra 53 ms, e não aparece no perfil. O fix é
wp option set-autoload <name> off. - OPcache desativado. Com o OPcache desativado, a página corrigida passou de 54 para 124 ms. Não fiz o profile deste caso: verifique a configuração e defina
opcache.enable=1para o PHP-FPM.
O core do WordPress sinaliza opções grandes com autoload: o Site Health avisa quando ultrapassam 800 KB em conjunto. Aplique o fix, mas sem uma object cache persistente, como neste site, não espere uma página mais rápida.

O que o PHP estava a fazer em cada página, a partir das amostras do phpspy no site de testes.
Como encontrar o plugin lento sem acesso ao servidor?
Sem acesso ao servidor, encontre o plugin lento do WordPress com o Query Monitor: mostra as queries à base de dados e as chamadas HTTP externas de uma página, agrupadas por plugin. O plugin Code Profiler acrescenta o tempo gasto no próprio código do plugin.
- Query Monitor. Mostra as queries à base de dados por plugin com o respetivo tempo, as lentas e as duplicadas, e cada chamada HTTP externa com a função chamadora e o plugin. É o primeiro ponto de análise, uma página de cada vez com sessão iniciada, e necessita apenas do plugin e de um login de administrador.
- Code Profiler. Mede o tempo de cada plugin e do tema numa página à sua escolha, no front-end ou na administração, além do I/O de ficheiros, para que veja que código PHP do próprio plugin é lento. Necessita do plugin e de um login de administrador; a base de dados e as chamadas remotas estão na versão Pro.
- Server-Timing (Performance Lab). Um plugin que adiciona a cada resposta o tempo antes do template e no template, para que o possa ler para um request no DevTools e nos field data através de RUM.
- O APM do alojamento. Lista o PHP, as queries à base de dados e as chamadas externas por transação, as mais lentas primeiro, em tráfego real. Funciona nos serviços de alojamento que o disponibilizam, assim que o ativam.
- PHP-FPM slowlog. Guarda um backtrace de PHP de cada request mais lento do que um timeout definido, o que apanha requests lentos em tráfego real durante dias. Necessita de acesso à configuração da pool, pelo que tem de ser configurado pelo alojamento ou por si com root.
Para ver a página de um membro no Query Monitor, inicie sessão como membro de teste com a permissão view_query_monitor ativa, ou defina primeiro o cookie de autenticação do Query Monitor no respetivo painel de definições. Na página de curso do site de testes, a visão geral indicava 0,89 s para a página, 88 queries em 0,28 s e uma chamada à API HTTP em 0,36 s, e dois painéis identificavam os plugins:

Query Monitor, Queries by Component, na página de curso do site de testes como membro.

Query Monitor, HTTP API Calls: o caller e o plugin da chamada externa.
O Query Monitor atribui 6 ms às 47 queries da caixa "Your progress", e isso está correto: os 104 a 125 ms que acrescenta são código PHP, o tempo que o Code Profiler e um profiler por amostragem mostram.
O slowlog do PHP-FPM regista um backtrace de cada request que demore mais do que o request_slowlog_timeout, e aceita esse timeout em segundos inteiros. No site de testes, 300ms foi interpretado como 300 segundos, por isso verifique o valor com sudo php-fpm8.4 -tt depois de o definir. A 1s, com a API de agendamento abrandada para 1,5 s apenas para este teste, cada request lento deixou um backtrace a partir de curl_exec() através de wp_remote_get() até acme_fetch_sessions() e acme_next_session() em acme-live-sessions.php.
Começo pelo Query Monitor na página lenta e passo para um profiler no servidor assim que obtenho root. Sem root, peça ao alojamento ou a um programador com root para fazer o profile das páginas lentas. Envie-lhes os URLs, se tinha sessão iniciada e com que função, os tempos observados e a captura de ecrã do Query Monitor.
Como fazer profiling de PHP num servidor em produção com o phpspy?
phpspy é um profiler por amostragem que lê as stacks dos workers do PHP-FPM em execução a partir do exterior, sem qualquer alteração ao PHP ou ao site. Em tráfego real, mostra o que o PHP estava a fazer em cada amostra e que plugin o chamou, bem como o tempo em código PHP. Necessita de Linux e de root no servidor.
1. Compile a partir da master. A última versão com tag, a v0.7.0 de julho de 2024, lista suporte para PHP até 8.3; para o PHP 8.4 e mais recentes, compile a partir da master (verificado a 20 de novembro de 2026).
git clone --recursive https://github.com/adsr/phpspy.git
cd phpspy
make
Em arm64 o README classifica o suporte como experimental para o PHP 8.3 e superior; funcionou no site de testes com o PHP 8.4.
2. Associe-o aos workers da pool. Execute-o como root, fora da webroot.
sudo ./phpspy -H 99 -b 131072 -T 4 -r u -P "-x php-fpm8.4" -o run.txt
-P passa o seu argumento ao pgrep, pelo que o phpspy segue todos os processos com esse nome exato: o master e os workers de cada pool. Utilize o nome de processo da sua versão de PHP. O phpspy usa uma thread por processo, pelo que -T 4 cobre o master e três workers; sob tráfego real defina-o para o pm.max_children da pool mais um. -H 99 é a taxa de amostragem em Hz, e -r u adiciona o URI do request a cada amostra. -b 131072 aumenta os bytes por trace face ao valor predefinido de 4 096, para que uma stack profunda do WordPress se mantenha num único trace.
3. Carregue as páginas lentas. Com sessão iniciada como o utilizador que as vê lentas, 30 vezes. Este loop imprime cada TTFB, sem sessão iniciada e como membro. A primeira linha inicia sessão uma vez e guarda o cookie do membro em member.jar; cb torna cada URL novo, pelo que cada request chega ao PHP.
curl -s -o /dev/null -c member.jar -d 'log=USERNAME&pwd=PASSWORD' https://example.com/wp-login.php
URL=https://example.com/course/dovetail-joints-1/
for i in $(seq 30); do
curl -s -o /dev/null -w "logged out %{time_starttransfer}\n" "$URL?cb=$RANDOM$RANDOM"
curl -s -o /dev/null -w "member %{time_starttransfer}\n" -b member.jar "$URL?cb=$RANDOM$RANDOM"
done
No PHP-FPM, todas as páginas de front-end têm o URI /index.php, por isso faça o profile de uma página de cada vez.
4. Pare a execução e desenhe o flame graph. O Ctrl-C interrompe-o, ou adicione -i 30000 para parar ao fim de 30 segundos. De seguida:
./stackcollapse-phpspy.pl <run.txt | ./vendor/flamegraph.pl >flame.svg
Cada linha do perfil colapsado é uma stack, de fora para dentro, com o número de amostras no final. Esta é a maior da página de curso do site de testes, reduzida às suas últimas frames:
{closure:/var/www/acme/wp-content/plugins/acme-live-sessions/acme-live-sessions.php:33};acme_next_session;acme_fetch_sessions;wp_remote_get;WP_Http::get;WP_Http::request;WpOrg\Requests\Requests::request;WpOrg\Requests\Transport\Curl::request;curl_exec 782
Leia-o a partir do fim. A última frame é o que o PHP estava a fazer: curl_exec está à espera de uma chamada externa, mysqli_query da base de dados, qualquer outra coisa é código PHP. O caminho do ficheiro identifica o plugin, aqui acme-live-sessions. Imediatamente antes das funções HTTP do WordPress encontra o código que pediu a espera, acme_fetch_sessions: a função que tem de corrigir.

Flame graph do phpspy da página de curso: 1 751 amostras ao longo de 30 requests.
Interprete o perfil em percentagens e conte com números baixos para o código PHP. No site de testes, o phpspy apanhou de 67 a 75% das amostras previstas pela sua taxa por request e registou 1 090 erros de leitura em 9 106 stacks, a maioria stacks que mudaram enquanto eram lidas. Uma stack muda enquanto o PHP corre código, pelo que as amostras perdidas são quase todas código PHP: a caixa de progresso recolheu 9% das amostras da página de curso, enquanto o seu fix poupou 125 de 793 ms.
É seguro fazer profiling num servidor em produção?
Sim, com limites. O phpspy lê os workers do PHP-FPM sem os pausar e não altera nada; no site de testes não adicionou tempo mensurável a um request. Para com Ctrl-C ou com um limite de tempo, e o PHP-FPM continua a correr.
- O que regista. Com
-r uapenas o URI. Deixe de foraqec: uma query string pode conter um endereço de email ou um token (no site de testes, a chave secreta que ativa um fix para um request), e os cookies guardam sessões de login. - A carga. A página de curso demorou 792 ms com o phpspy associado e 793 ms sem ele. O próprio phpspy utilizou 0,7% de CPU e 1,9 MB de memória.
- Quanto tempo. Alguns minutos enquanto carrega as páginas lentas são suficientes. A saída cresce cerca de 3 MB por minuto a um request de cada vez, e mais depressa com tráfego real.
- Para onde vai a saída. Fora da webroot, e eliminada quando terminar: contém URIs e caminhos de ficheiros do seu site.
Nunca adicione -S num servidor em produção: pausa o processo PHP enquanto o phpspy o lê.
Como corrigir as funções lentas dos plugins?
Retirar a espera ou o trabalho repetido do request do visitante é o que torna rápida uma função lenta de um plugin. Os três fixes abaixo fazem isso no site de testes, encurtados a partir dos seus plugins.
Para a chamada externa, guarde a resposta num transient e deixe o WP-Cron procurá-la no seu próprio request. Enquanto o transient estiver vazio, a caixa não mostra nada.
function acme_next_session() {
$data = get_transient( 'acme_next_session' );
if ( false === $data && ! wp_next_scheduled( 'acme_refresh_sessions' ) ) {
wp_schedule_single_event( time(), 'acme_refresh_sessions' );
}
if ( ! $data ) {
return '';
}
return '<p class="acme-next">Next live session: ' . esc_html( $data['title'] ) . ', ' . esc_html( $data['when'] ) . '</p>';
}
add_action( 'acme_refresh_sessions', function () {
set_transient( 'acme_next_session', acme_fetch_sessions(), 15 * MINUTE_IN_SECONDS );
} );
Na pesquisa em meta_value (lookup), atribua a cada curso o seu instrutor como termo uma vez e encontre os outros cursos com uma tax_query. As tabelas de termos têm índices; meta_value não.
add_action( 'init', function () {
register_taxonomy( 'instructor', array( 'course' ), array( 'public' => true, 'label' => 'Instructors' ) );
} );
// Once, for every course: the instructor's name as a term.
wp_set_object_terms( $course_id, get_post_meta( $course_id, 'instructor_name', true ), 'instructor' );
// On the course page: the other courses with the same term.
$terms = wp_get_post_terms( $course_id, 'instructor', array( 'fields' => 'ids' ) );
$q = new WP_Query( array(
'post_type' => 'course',
'tax_query' => array( array( 'taxonomy' => 'instructor', 'terms' => $terms ) ),
'post__not_in' => array( $course_id ),
'posts_per_page' => 4,
'no_found_rows' => true,
) );
O resumo de progresso mantém-se inalterado até o membro terminar uma lição. Construa-o nessa altura, guarde-o no user meta e leia-o a partir daí em todas as outras páginas.
function acme_progress_summary( $user_id ) {
$rows = get_user_meta( $user_id, 'acme_progress_cache', true );
if ( ! is_array( $rows ) ) {
$rows = acme_build_progress( $user_id );
update_user_meta( $user_id, 'acme_progress_cache', $rows );
}
return $rows;
}
// A finished lesson rebuilds the summary.
add_action( 'acme_lesson_completed', function ( $user_id ) {
update_user_meta( $user_id, 'acme_progress_cache', acme_build_progress( $user_id ) );
} ); Como provar que o fix tornou o backend mais rápido?
Coloque o fix atrás de um switch que apenas você possa acionar, carregue a página com e sem ele por ordem aleatória nas mesmas rondas e compare as diferenças emparelhadas. No site de testes, os três fixes em conjunto reduziram a página de curso do membro de 793 para 32 ms.
- Construa o switch. O fix corre apenas quando o request inclui uma chave secreta, verificada com
hash_equals; uma chave errada não altera nada. O request tem também de contornar a cache de página (no site de testes, qualquer query string o fazia). Verifique ambos antes da primeira medição: o cabeçalho de resposta indica que partes estão desativadas.<?php // wp-content/mu-plugins/acme-switch.php // ?acme_key=<key>&acme_off=s1,s2 turns those parts off for this request only. // The key is ACME_SWITCH_KEY in wp-config.php. function acme_off( $part ) { static $off = null; if ( null === $off ) { $off = array(); if ( defined( 'ACME_SWITCH_KEY' ) && isset( $_GET['acme_key'], $_GET['acme_off'] ) && hash_equals( ACME_SWITCH_KEY, (string) $_GET['acme_key'] ) ) { $off = array_filter( explode( ',', (string) $_GET['acme_off'] ) ); } header( 'X-Acme-Off: ' . ( $off ? implode( ',', $off ) : 'none' ) ); } return in_array( $part, $off, true ) || in_array( 'all', $off, true ); } // In the plugin, around the slow part: if ( acme_off( 's1' ) ) { $data = get_transient( 'acme_next_session' ); // the fix } else { $data = acme_fetch_sessions(); // the old code } - Meça em rondas. Cada ronda carrega cada variante uma vez por ordem aleatória, como o utilizador que tem o problema, com o
time_starttransferdo curl como TTFB.KEY=your-secret-key URL=https://example.com/course/dovetail-joints-1/ for round in $(seq 30); do for off in $(printf '%s\n' none s1 s2 s3 all | sort -R); do t=$(curl -s -o /dev/null -b member.jar -w '%{time_starttransfer}' \ "$URL?acme_key=$KEY&acme_off=$off&cb=$RANDOM$RANDOM") echo "$round $off $t" done done >rounds.txt - Compare por ronda. Calcule a diferença entre as variantes em cada ronda e, em seguida, a mediana e a dispersão dessas diferenças. A carga do servidor que se altere durante o teste afeta ambas as variantes na mesma ronda, pelo que desaparece da diferença.
- Passe a produção e observe os field data. No dia seguinte, a parte do request do TTFB para os visitantes com sessão iniciada no seu RUM, como o CoreDash, revela o fix.
No site de testes, a chamada externa poupou uma mediana de 401 ms (intervalo de 95% entre 386 e 412), a meta query 277 (249 a 299) e a caixa de progresso 125 (94 a 144), cada uma com as restantes partes lentas ativas. Nenhum dos três intervalos se aproxima de zero, pelo que nenhum destes ganhos é ruído. Na página de lição, onde a caixa do instrutor não aparece, o fix da meta query poupou apenas 4 ms, tal como esperado.

TTFB mediano ao longo de 30 rondas no site de testes, medido com curl.
Membros à espera em todas as páginas e um perfil ou ecrã do Query Monitor que ainda não consegue interpretar? Traga o caso para uma hora comigo dedicada ao seu backend lento. Analisamos tudo em conjunto, encontramos o plugin e a função, e definimos o que o seu alojamento ou programador deve alterar primeiro.

Precisa de um site mais rápido?
Sou o Arjen e há 17 anos que corrijo sites lentos. Se tem problemas que não consegue resolver sozinho, envie-me o seu URL e falamos.
Envie-me o seu URL
Porque é que o nosso fix não está a funcionar?
Por vezes a CDN ainda serve o HTML antigo, ou o fix foi feito no template de desktop e o mobile usa outro. Envie-me o seu URL e o problema, e respondo com alguns horários. Primeiro analiso os seus field data, depois dedicamos uma hora ao seu site, e no prazo de um dia tem as minhas notas por escrito. 350 € sem IVA.
Envie-me o seu URLSem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.