blog
Servidores

Slow query log do MySQL: ativar e achar a consulta lenta

O critério numérico que separa índice faltando de falta de recurso, nos três cenários de permissão: my.cnf com root, SET GLOBAL sem reiniciar e performance_schema em conta sem SUPER.

JR · · 11 min de leitura · 2 tabelas · 15 blocos de código

Resposta curta: ative o slow query log com long_query_time = 0.5 e classifique cada digest pela razão Rows_examined/Rows_sent: acima de ~100 linhas lidas por linha devolvida com Lock_time perto de zero é índice faltando; razão perto de 1 com Query_time alto é IO, volume ou contenção.

Neste artigo
  1. Rows_examined dividido por Rows_sent é o critério de triagem
  2. O que cada linha de uma entrada do slow log diz
  3. Três formas de ativar, conforme o seu nível de acesso
  4. Configurar o log para ele não encher de ruído
  5. Agregar por digest antes de ler o arquivo
  6. Confirmar o plano com EXPLAIN antes de criar índice
  7. Do digest de volta ao código que disparou a consulta
  8. Quanto custa deixar ligado e como reverter

Ativar o slow_query_log é a parte fácil. O que costuma faltar é o critério para ler o arquivo: com trinta digests no relatório, qual deles justifica criar índice, qual justifica reescrever a consulta e qual é sintoma de concorrência ou IO, não de SQL ruim. A razão entre linhas examinadas e linhas devolvidas resolve a maior parte dessa triagem em segundos, antes de qualquer EXPLAIN.

Este artigo é documental. Não há medição da Napoleon aqui: os trechos de log e os números dentro deles são exemplos rotulados como exemplos, e o procedimento de ativação em servidor cPanel segue a documentação oficial do cPanel.

Rows_examined dividido por Rows_sent é o critério de triagem

Cada entrada do slow log traz Rows_sent (linhas entregues ao cliente) e Rows_examined (linhas que o servidor teve que ler, no storage engine, para produzir aquelas linhas). A divisão entre os dois é um estimador direto de seletividade de acesso.

Se uma consulta devolve 12 linhas e examinou 418.922, o servidor fez varredura e descartou quase tudo em memória. Nenhum ajuste de innodb_buffer_pool_size conserta isso de forma estrutural: o trabalho existe porque o caminho de acesso é errado, e ele cresce junto com a tabela.

Se a consulta devolve 250.000 linhas e examinou 251.100, o caminho de acesso está correto. O tempo alto vem de outro lugar: volume legítimo de dados (falta de LIMIT, export, relatório), IO frio, CPU disputada ou espera por lock. Aí a leitura muda de "falta índice" para "falta recurso ou falta paginação".

Sinal na entrada do log Rows_examined / Rows_sent Lock_time Leitura provável Primeira ação
Poucas linhas devolvidas, muitas lidas acima de ~100 próximo de 0 índice ausente ou não usado no filtro EXPLAIN e índice composto no WHERE + ORDER BY
Linhas lidas proporcionais ao resultado, Query_time alto próximo de 1 próximo de 0 volume de dados, IO ou CPU paginar, reduzir colunas, cachear, revisar recurso
Lock_time responde por boa parte do Query_time qualquer dominante espera por lock de tabela ou metadata lock: DDL em andamento, LOCK TABLES, backup performance_schema.metadata_locks e sys.schema_table_lock_waits
Muitas linhas lidas e muitas devolvidas acima de 10 e Rows_sent na casa dos milhares baixo consulta sem LIMIT servindo tela paginada corrigir a aplicação, não o banco
Rows_sent: 0 repetido, Rows_examined alto infinito na prática baixo checagem de existência varrendo tabela índice no predicado, EXISTS em vez de COUNT(*)

O limite de ~100 é heurística de triagem, não constante do MySQL. Serve para ordenar a fila de trabalho: os digests com razão de três dígitos quase sempre são resolvidos por índice, e resolvidos sem trocar de plano.

Triagem de entrada do slow log por razãoLeia Rows_examined / Rows_sentDivida os dois campos da entradaRazão de tres digitos, Lock_time ~0Fila de indice: EXPLAIN e indice compostoRazão perto de 1, Query_time altoFila de recurso: paginar, cachear, IO, CPULock_time domina o Query_timeFila de DDL e backup: metadata_locksRows_sent 0 com examinadas altasChecagem de existencia varrendo tabela
Triagem do slow log antes de qualquer EXPLAIN. O corte de ~100 na razão é heurística de fila de trabalho, não constante do MySQL.

O que cada linha de uma entrada do slow log diz

O exemplo abaixo é fictício, escrito para este artigo:

# Time: 2026-09-17T03:14:22.118371Z
# User@Host: siteuser[siteuser] @ localhost []  Id: 41288
# Query_time: 2.417533  Lock_time: 0.000112  Rows_sent: 12  Rows_examined: 418922
use siteuser_wp;
SET timestamp=1789614862;
SELECT p.ID, p.post_title FROM wp_posts p
  JOIN wp_postmeta m ON m.post_id = p.ID
 WHERE m.meta_key = 'evento_data' AND m.meta_value >= '2026-09-01'
 ORDER BY m.meta_value ASC LIMIT 12;

Razão: 418922 / 12, ou seja, cerca de 34.900 linhas lidas por linha entregue. Lock_time é 0,0001 s, então ninguém está esperando lock. Query_time de 2,41 s é trabalho próprio da consulta. Isso é o primeiro caso da tabela, e o alvo é o predicado em meta_value mais a ordenação pelo mesmo campo.

Contraste, também fictício:

# Query_time: 3.882104  Lock_time: 3.410992  Rows_sent: 1  Rows_examined: 1
SELECT option_value FROM wp_options WHERE option_name = 'siteurl' LIMIT 1;

Uma linha lida para uma devolvida, plano perfeito, e 3,41 s dos 3,88 s gastos esperando. A consulta é vítima.

Vale precisar o que Lock_time mede, porque isso muda a tabela onde você vai procurar o culpado: no slow log, Lock_time é espera por lock de tabela e por metadata lock (MDL), adquiridos pela camada SQL antes da execução. Espera por row lock do InnoDB não aparece em Lock_time: ela fica embutida no Query_time. Então um Lock_time de 3,41 s aponta para ALTER TABLE ou outro DDL segurando MDL exclusivo, LOCK TABLES, FLUSH TABLES WITH READ LOCK de backup, ou mysqldump sem --single-transaction em tabelas MyISAM.

Onde olhar em cada caso:

-- espera por MDL / lock de tabela: quem detém e quem espera
-- (MySQL 8 instrumenta wait/lock/metadata/sql/mdl por padrão;
--  em 5.7 confira setup_instruments antes de confiar na tabela vazia)
SELECT OBJECT_TYPE, OBJECT_SCHEMA, OBJECT_NAME,
       LOCK_TYPE, LOCK_STATUS, OWNER_THREAD_ID
  FROM performance_schema.metadata_locks
 WHERE OBJECT_TYPE IN ('TABLE','SCHEMA','GLOBAL');

SELECT * FROM sys.schema_table_lock_waits;
-- espera por row lock: não aparece em Lock_time, aparece dentro de Query_time
SELECT trx_id, trx_started, trx_state, trx_rows_locked, trx_query
  FROM information_schema.INNODB_TRX
 ORDER BY trx_started;

SELECT * FROM performance_schema.data_lock_waits;

Regra de bolso: Lock_time alto manda você para metadata_locks e para quem está fazendo DDL ou backup. Lock_time perto de zero com Query_time alto e razão perto de 1 pode ser row lock, e aí a fonte é INNODB_TRX e data_lock_waits. SHOW FULL PROCESSLIST serve para os dois, procurando estados como Waiting for table metadata lock.

Três formas de ativar, conforme o seu nível de acesso

Com root no servidor, editando o my.cnf

É o caminho persistente. A documentação do cPanel descreve editar /etc/my.cnf, na seção [mysqld], e reiniciar o serviço do MySQL ou MariaDB para que o log passe a ser gravado; o arquivo de destino precisa existir e pertencer ao usuário do banco, caso contrário o serviço não consegue escrever nele. Consulte o procedimento e os caminhos exatos na página oficial antes de mexer, porque o layout de diretórios varia com a versão do servidor.

[mysqld]
slow_query_log = 1
slow_query_log_file = /var/log/slowquery.log
long_query_time = 0.5
min_examined_row_limit = 0
log_queries_not_using_indexes = 0
log_output = FILE

min_examined_row_limit = 0 é deliberado, e é o padrão do servidor. Esse piso descarta do slow log qualquer entrada abaixo do valor, incluindo a do segundo exemplo acima (Rows_examined: 1 com 3,41 s de espera por lock). Se você subir para 1000 de saída, some exatamente a linha de contenção da tabela de triagem. Suba só na janela em que log_queries_not_using_indexes estiver ligado, como explicado adiante.

Depois do restart, confirme o que o servidor realmente carregou, em vez de confiar no arquivo:

SHOW GLOBAL VARIABLES WHERE Variable_name IN
 ('slow_query_log','slow_query_log_file','long_query_time',
  'min_examined_row_limit','log_queries_not_using_indexes','log_output');

Risco a considerar: reiniciar o serviço derruba conexões abertas. Se o site está em pico, prefira o caminho 2 agora e deixe o my.cnf para a próxima janela.

Sem reiniciar o serviço, com SET GLOBAL

slow_query_log, long_query_time, min_examined_row_limit e log_queries_not_using_indexes são variáveis dinâmicas. Com privilégio administrativo (SYSTEM_VARIABLES_ADMIN no MySQL 8, SUPER no MariaDB), dá para ligar o log em produção sem downtime:

SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 0.5;
SET GLOBAL min_examined_row_limit = 0;   -- mantém entradas de Lock_time alto

Dois detalhes que costumam custar meia hora de confusão:

Sem privilégio SUPER, lendo o performance_schema

Em conta compartilhada você não liga o slow log, mas o servidor pode já estar agregando tudo que você precisa. Se performance_schema estiver ativo e o consumidor statements_digest habilitado, a tabela events_statements_summary_by_digest traz exatamente as duas colunas do critério, somadas por digest:

SELECT SCHEMA_NAME,
       LEFT(DIGEST_TEXT, 100)                            AS consulta,
       COUNT_STAR                                        AS execs,
       ROUND(SUM_TIMER_WAIT/1e12, 2)                     AS total_s,
       ROUND(AVG_TIMER_WAIT/1e9, 2)                      AS media_ms,
       SUM_ROWS_SENT                                     AS enviadas,
       SUM_ROWS_EXAMINED                                 AS examinadas,
       ROUND(SUM_ROWS_EXAMINED/GREATEST(SUM_ROWS_SENT,1), 1) AS razao,
       ROUND(SUM_LOCK_TIME/1e12, 2)                      AS lock_s,
       SUM_NO_INDEX_USED                                 AS sem_indice,
       SUM_CREATED_TMP_DISK_TABLES                       AS tmp_disco
  FROM performance_schema.events_statements_summary_by_digest
 ORDER BY SUM_TIMER_WAIT DESC
 LIMIT 15;

Os timers do performance_schema são picossegundos, daí /1e12 para segundos e /1e9 para milissegundos. SUM_LOCK_TIME tem a mesma semântica do Lock_time do slow log: espera por lock de tabela e metadata, não row lock. SUM_NO_INDEX_USED é o contador equivalente ao que log_queries_not_using_indexes registraria, sem precisar escrever nada em disco. SUM_CREATED_TMP_DISK_TABLES acima de zero em digest com ORDER BY ou GROUP BY indica materialização em disco, que é outra causa clássica de Query_time alto com razão baixa.

Se o MySQL tem o schema sys disponível, a view sys.statement_analysis já entrega rows_examined_avg e rows_sent_avg prontas e ordenadas, e é o atalho preferível.

Duas limitações honestas deste caminho: performance_schema só pode ser ligado na inicialização do servidor (não é dinâmico), e nem toda hospedagem concede SELECT nele para usuário de conta. Se os dois bloqueios se aplicam, o diagnóstico sai do banco e vai para a aplicação: log de consultas do próprio framework, SAVEQUERIES no WordPress com Query Monitor, APM. Nada disso exige upgrade de plano, e é bom checar antes de contratar mais CPU.

Configurar o log para ele não encher de ruído

O valor padrão de long_query_time é 10 segundos. Em site que responde em 400 ms de TTFB, esse limiar registra quase nada. Fracionário resolve: 0.5 já captura o que realmente pesa em uma página, e a resolução de microssegundos vale quando o log vai para arquivo.

log_queries_not_using_indexes é a variável que mais gera arquivo inútil. Ligada sozinha, ela registra qualquer consulta que não usou índice, inclusive SELECT em tabela de 8 linhas onde a varredura é a escolha certa do otimizador. O amortecedor usual é min_examined_row_limit, e é aqui que mora a pegadinha.

min_examined_row_limit não é um filtro específico de log_queries_not_using_indexes. Ele é um piso global do slow log: qualquer consulta que examinou menos linhas que o valor fica fora do arquivo, inclusive as que passaram do long_query_time com folga. Com min_examined_row_limit = 1000, a entrada de Rows_examined: 1 e Lock_time: 3.41 do exemplo acima nunca é gravada, e a linha de contenção da tabela de triagem deixa de existir na prática. Conclusão operacional:

Variável Sugestão inicial Efeito
long_query_time 0.5 limiar em segundos, aceita fração
min_examined_row_limit 0 no geral, 1000 só com log_queries_not_using_indexes ligado piso global: descarta toda entrada que examinou menos linhas que o valor, inclusive as de Lock_time alto
log_queries_not_using_indexes ligar só por janelas curtas captura varredura abaixo do limiar de tempo
log_output FILE TABLE grava em mysql.slow_log e custa escrita no próprio banco
log_slow_admin_statements ligar durante manutenção inclui ALTER, OPTIMIZE, ANALYZE, úteis justamente quando a suspeita é MDL

Algumas versões oferecem limitadores de taxa para não inundar o arquivo (throttle de consultas sem índice no MySQL, amostragem no MariaDB). Os nomes e o comportamento variam entre implementação e versão, então confirme na documentação da sua build antes de colocar no my.cnf.

Agregar por digest antes de ler o arquivo

Ler o arquivo bruto com tail serve para confirmar que o log está escrevendo. Para decidir, agregue por digest, porque a consulta que aparece 4.000 vezes a 0,6 s dói mais que a que aparece uma vez a 9 s.

mysqldumpslow vem com o servidor e não precisa de instalação:

# top 10 por tempo total acumulado
mysqldumpslow -s t -t 10 /var/log/slowquery.log

# top 10 por tempo médio, útil para achar o pior plano
mysqldumpslow -s at -t 10 /var/log/slowquery.log

# filtrar por tabela suspeita
mysqldumpslow -s t -g 'wp_postmeta' /var/log/slowquery.log

pt-query-digest, do Percona Toolkit, dá o relatório que responde direto ao critério deste artigo, porque imprime distribuição de Rows examine e Rows sent por digest, além de percentis de tempo e de Lock time:

pt-query-digest --limit 5 /var/log/slowquery.log > /root/digest.txt

No relatório, compare a coluna de linhas examinadas com a de linhas enviadas em cada bloco de query. Razão de três dígitos, com Lock time perto de zero, é fila de índice. Razão perto de 1 com Query_time alto é fila de recurso ou de paginação. Lock time com percentil 95 alto é fila de DDL e backup, não de SQL.

O arquivo do slow log preserva comentários SQL, e pt-query-digest também. O DIGEST_TEXT do performance_schema normaliza o texto. Quando o objetivo é atribuição de origem, o arquivo é a fonte melhor.

Confirmar o plano com EXPLAIN antes de criar índice

Razão alta é indício, não diagnóstico. Rode EXPLAIN na consulta exatamente como ela aparece no log, com os mesmos valores literais, porque o otimizador escolhe plano em função da cardinalidade estimada dos parâmetros:

EXPLAIN FORMAT=JSON
SELECT p.ID, p.post_title FROM wp_posts p
  JOIN wp_postmeta m ON m.post_id = p.ID
 WHERE m.meta_key = 'evento_data' AND m.meta_value >= '2026-09-01'
 ORDER BY m.meta_value ASC LIMIT 12;

O que procurar no JSON: access_type igual a ALL na tabela grande, rows_examined_per_scan na casa das centenas de milhares, using_filesort verdadeiro, using_temporary_table verdadeiro, e possible_keys vazio.

Para medir de fato em vez de estimar, existe execução instrumentada: EXPLAIN ANALYZE SELECT ... no MySQL 8.0.18 ou superior, e ANALYZE FORMAT=JSON SELECT ... no MariaDB. As duas formas executam a consulta. Consequência prática: não use em UPDATE ou DELETE fora de transação que você vai reverter, e prefira réplica ou janela de baixo movimento quando a consulta for a que está derrubando o site.

Depois de criar o índice candidato, repita EXPLAIN e volte ao slow log. O sinal de sucesso é o mesmo digest reaparecendo com Rows_examined perto de Rows_sent, ou desaparecendo do log porque caiu abaixo do limiar.

Ciclo de coleta e diagnóstico da consulta lentaAtivarlong_query_time 0.5, min_examined 0ColetarJanela com pico e cronAgregarpt-query-digest ou digest do P_SConfirmarEXPLAIN FORMAT=JSON com literais do logReverterDesligar, rotacionar, guardar a base
Ciclo de diagnóstico fechado: o relatório da janela inicial vira a linha de base para comparar depois do índice.

Do digest de volta ao código que disparou a consulta

A consulta lenta raramente tem autor óbvio, sobretudo em CMS com dezenas de plugins. Três formas de fechar a atribuição:

Comentário de rota carimbado na própria consulta

O caminho mais confiável é instrumentar a aplicação para carimbar a origem. O comentário viaja até o slow log:

$sql = "/* rota:/relatorio-mensal origem:acme-reports */ "
     . "SELECT ... FROM pedidos WHERE ...";

Depois, grep 'origem:acme-reports' /var/log/slowquery.log fecha o caso. Em framework com ORM, isso normalmente é um hook único no builder de query.

Pegar a consulta em flagrante no processlist

Enquanto o problema acontece, SHOW FULL PROCESSLIST mostra usuário, banco, tempo, estado e a consulta completa. Correlacione o Id da conexão com o Id: que aparece no cabeçalho # User@Host da entrada do slow log. Estado Waiting for table metadata lock confirma o cenário de Lock_time alto sem precisar de mais nada. Em servidor com vários sites por instância, o use nome_do_banco; gravado logo antes da consulta já identifica a conta.

No WordPress, comece pelo autoload de wp_options

Quando o digest lento é em wp_options, wp_postmeta ou wp_posts, verifique o volume carregado em toda requisição:

SELECT option_name, autoload, LENGTH(option_value) AS bytes
  FROM wp_options
 ORDER BY bytes DESC
 LIMIT 20;

Opções grandes marcadas para carregar sempre (transients órfãos, cache de plugin, logs guardados em option) fazem cada pageview pagar por elas. Versões recentes do WordPress mudaram os valores aceitos na coluna autoload, então confira quais valores aparecem na sua instalação antes de filtrar por igualdade.

Para amarrar consulta a plugin no nível do PHP, define('SAVEQUERIES', true); no wp-config.php mais o plugin Query Monitor mostram a pilha de chamada de cada query. Isso custa memória e grava tudo em cada request: ligue em staging, ou em produção por minutos, e desligue.

Quanto custa deixar ligado e como reverter

Cada entrada do slow log são quatro a seis linhas de texto, escritas de forma síncrona no arquivo. Com limiar de 0,5 s e log_queries_not_using_indexes desligado, o volume é pequeno mesmo com min_examined_row_limit = 0. Com log_queries_not_using_indexes ligado e sem piso de linhas, o arquivo cresce rápido, e partição cheia é incidente pior do que a consulta lenta original: o servidor pode falhar em escrever log, e a partição do sistema afeta todo o resto.

Três precauções:

Janela típica de coleta: um período que contenha o pico do site e as rotinas agendadas (cron, backup, importação). As rotinas agendadas são justamente onde aparecem os Lock_time altos, então não corte a janela antes delas. Depois disso, desligue.

-- reversão dinâmica, sem restart
SET GLOBAL slow_query_log = 'OFF';
SET GLOBAL log_queries_not_using_indexes = 'OFF';
SET GLOBAL long_query_time = 10;
SET GLOBAL min_examined_row_limit = 0;
# reversão persistente: remover as linhas do [mysqld] e reiniciar o serviço
# depois, guardar o arquivo fora do servidor e liberar o espaço
gzip /var/log/slowquery.log && mv /var/log/slowquery.log.gz /root/

Se você usou SET PERSIST no MySQL 8, a reversão completa exige RESET PERSIST slow_query_log; (e as demais variáveis), senão o valor volta no próximo restart a partir do mysqld-auto.cnf.

Guarde o relatório do pt-query-digest da janela antes da correção. Ele é a linha de base contra a qual você compara o log depois do índice, e é o que permite afirmar que a mudança funcionou em vez de supor.

Referências

  1. Documentação oficial (cpanel) — How to Enable the Slow Query Log in MySQL or MariaDB. Consultado em 2026-09-17.
Leia também