# Como ver qual consulta está travando o MySQL do site

Como achar a thread que segura a fila no instante do travamento, encerrar só ela e chegar ao plugin ou relatório que a gera, sem trocar de plano antes da hora.

> rode SHOW FULL PROCESSLIST (ou a tela Show Database Processes do WHM), ordene pela coluna Time, copie o texto da consulta mais antiga e encerre só ela com KILL QUERY. Depois ache o plugin ou relatório que a dispara antes de pensar em trocar de plano.

João Rizzon · 2026-11-11 · Servidores

---

## Por que o slow log não responde a essa pergunta

Quando o site trava agora, o slow query log ajuda pouco no primeiro minuto. Ele registra a consulta depois que ela termina, e a consulta que segura a fila ainda não terminou. Por isso ela ainda não está lá. Ver os processos do sistema também não resolve: o `top` mostra o `mysqld` (ou `mariadbd`) consumindo CPU, mas não diz qual das conexões abertas está fazendo isso.

A lista de threads do próprio banco responde. Ela mostra cada conexão aberta, o que está executando e há quantos segundos. Ordenada pelo tempo, a consulta problemática costuma aparecer no topo. Antes de matar qualquer coisa, copie o texto dela, porque é esse texto que leva ao plugin ou ao relatório responsável.

Este guia é documental: não traz medição da Napoleon. Os comandos são do MySQL e do MariaDB padrão, e o caminho pelo painel segue a [documentação oficial do cPanel sobre Show Database Processes](https://docs.cpanel.net/whm/database-services/show-database-processes/). As saídas mostradas mais abaixo são exemplos ilustrativos.

## Como listar as consultas ativas

### Pelo WHM, se você administra o servidor

No WHM, o caminho é **Database Services » Show Database Processes**. Segundo a [documentação do cPanel](https://docs.cpanel.net/whm/database-services/show-database-processes/), a tela lista os processos ativos do servidor de banco de dados e permite encerrar um processo específico. É o jeito mais rápido quando o cliente está ao telefone e você não quer abrir terminal.

### Pelo terminal

Com acesso root ou um usuário com privilégio `PROCESS`, o comando básico é:

```sql
SHOW FULL PROCESSLIST;
```

O `FULL` importa: sem ele, a coluna `Info` corta o texto da consulta, e você perde justamente o trecho que identifica a origem.

Para ordenar pelo tempo e esconder conexões ociosas, consulte a mesma informação pela tabela `information_schema.PROCESSLIST`, que existe no MySQL e no MariaDB:

```sql
SELECT ID, USER, DB, COMMAND, TIME, STATE, LEFT(INFO, 200) AS consulta
FROM information_schema.PROCESSLIST
WHERE COMMAND <> 'Sleep'
ORDER BY TIME DESC;
```

Rode duas ou três vezes com alguns segundos de intervalo. Uma consulta que reaparece no topo com `TIME` crescendo é a candidata. Uma que some na segunda execução era só pico.

O filtro de `Sleep` tem um ponto cego. Se há threads em `Waiting for table metadata lock` e nenhuma `Query` longa na frente delas, quem segura o lock costuma ser uma transação que ficou aberta: a conexão aparece como `Sleep`, com `Info` vazio (`NULL`), e o filtro a esconde. Nesse caso, rode a consulta sem a linha `WHERE COMMAND <> 'Sleep'` e procure a conexão ociosa com maior `TIME` do mesmo usuário e banco das que esperam. No InnoDB, `SELECT trx_mysql_thread_id, trx_started FROM information_schema.INNODB_TRX;` lista as transações abertas e o `Id` de cada uma, o que confirma a suspeita. Não mate o `ALTER` nem as consultas em espera: elas são vítimas.

### Em hospedagem compartilhada

Sem o privilégio `PROCESS`, o MySQL mostra apenas as threads do seu próprio usuário. Para quem cuida de um site em servidor compartilhado, isso basta: rode o `SHOW FULL PROCESSLIST` pelo phpMyAdmin ou pelo terminal, conectado com o usuário do banco daquele site, e você vê o que o site está executando. O que você não vê é a consulta de outro cliente do mesmo servidor, e aí o diagnóstico é com o suporte.

## Como ler cada coluna

| Coluna | O que mostra | O que procurar |
|---|---|---||
| `Id` | Identificador da thread | É o número que vai no `KILL` |
| `User` | Usuário do banco | Em servidor com vários sites, aponta qual cliente |
| `db` | Banco em uso | Confirma o site |
| `Command` | Tipo de atividade (`Query`, `Sleep`, `Connect`) | `Query` com tempo alto |
| `Time` | Segundos no estado atual | Ordene por aqui |
| `State` | Etapa da execução | Esperas por lock indicam fila |
| `Info` | Texto da consulta | Tabela, `meta_key`, prefixo de plugin |

Dois padrões aparecem com frequência. No primeiro, uma consulta roda há muito tempo e várias outras estão paradas com `State` indicando espera por lock (por exemplo `Waiting for table metadata lock` ou `Locked`). A culpada é a mais antiga, não as que esperam. Se nenhuma consulta ativa for mais antiga que as que esperam, a culpada provavelmente é uma conexão em `Sleep` com transação aberta (veja o aviso sobre o filtro na seção anterior). No segundo, não há nenhuma consulta longa, mas dezenas de consultas curtas e parecidas em sequência. Isso é volume, e o tratamento é outro (veja a seção sobre plano).

Exemplo ilustrativo, não uma captura real:

```
Id    User      db        Command  Time  State                            consulta
4821  cli_loja  cli_loja  Query    312   Sending data                     SELECT ... FROM wp_wc_orders o JOIN wp_wc_orders_meta om ...
4830  cli_loja  cli_loja  Query    95    Waiting for table metadata lock  ALTER TABLE wp_wc_orders ...
4833  cli_loja  cli_loja  Query    40    Waiting for table metadata lock  SELECT ... FROM wp_wc_orders ...
```

Nesse exemplo, a thread 4821 é a que segura a fila: ela lê `wp_wc_orders` há 312 segundos, o `ALTER TABLE` da 4830 precisa esperar ela terminar, e a 4833 fica atrás do `ALTER`. As outras são consequência.

## Encerrar só a consulta culpada com KILL QUERY

Copie o `Info` completo antes. Depois:

```sql
KILL QUERY 4821;
```

`KILL QUERY` interrompe a instrução e mantém a conexão. `KILL 4821` derruba a conexão inteira. Comece pelo `KILL QUERY`: é a intervenção menor, e a aplicação lida melhor com uma consulta que falhou do que com uma conexão que sumiu. A documentação do cPanel diz que a tela Show Database Processes permite encerrar um processo, mas não especifica se encerra só a consulta ou a conexão inteira. Quando essa diferença importa, use o terminal e o `KILL QUERY`.

Valide rodando a listagem de novo. A thread deve sumir ou aparecer com estado `Killed`. As consultas que esperavam por lock devem andar em poucos segundos.

Cuidados que evitam piorar a situação:

- **Escrita grande em InnoDB desfaz o que fez.** Um `UPDATE` ou `DELETE` em muitas linhas interrompido entra em rollback, e o rollback pode levar tanto tempo quanto a execução. A thread fica em `Killed` nesse período. Não reinicie o MySQL por impaciência: o rollback continua na inicialização.
- **Não mate threads de sistema** (replicação, `event_scheduler`, usuários internos do painel). Mate pelo `Id` de um usuário de site que você reconhece.
- **Transação ociosa não tem consulta para interromper.** Se a culpada é uma conexão em `Sleep` segurando lock, `KILL QUERY` não faz nada. Use `KILL` no `Id` dela: a conexão cai, a transação é desfeita e o lock é liberado.
- **Não use KILL em massa.** Matar todas as threads resolve o sintoma por segundos e apaga a evidência.
- **Sem privilégio de administrador, você só encerra as próprias threads.** Em compartilhada, isso cobre o seu site.

## Do texto da consulta ao plugin que a dispara

O `KILL` compra tempo. Se a origem continuar ativa, a mesma consulta volta no próximo acesso ou no próximo cron. O texto guardado na coluna `Info` é a pista.

### O que o próprio SQL revela sobre a origem

- **Prefixo de tabela de plugin.** Tabelas como `wp_wc_*` (WooCommerce), `wp_actionscheduler_*` (Action Scheduler, usado por vários plugins), `wp_yoast_*` ou tabelas de log de plugins de segurança e de formulário apontam o dono direto.
- **`meta_key` específica.** Em consultas sobre `wp_postmeta` ou `wp_usermeta`, o nome da chave costuma carregar o prefixo do plugin. Procure no código: `grep -rl "nome_da_chave" wp-content/plugins/`.
- **`wp_options` com `autoload`.** Consulta lenta aqui geralmente é tabela de opções inchada por transients ou dados que plugins gravam com autoload.
- **Agregações com `SUM`, `COUNT`, `GROUP BY` sobre pedidos ou visitas.** Quase sempre é relatório: dashboard de vendas, estatísticas, exportação.

### Como cruzar o horário do travamento com o log de acesso

Cruze o momento do travamento com o log de acesso do site. Uma requisição a `/wp-admin/admin.php?page=` de um relatório, a `wp-cron.php` ou a `admin-ajax.php` no mesmo minuto costuma fechar o caso. Se o travamento se repete em horário fixo, desconfie de cron: `wp cron event list` (WP-CLI) mostra o que está agendado.

### Como confirmar que o plugin é a origem

Desative o plugin suspeito em homologação ou num horário calmo e observe se a consulta volta a aparecer na listagem. Se o plugin é necessário, as saídas usuais são: limitar o período do relatório, mover a exportação para fora do horário de pico, limpar a tabela de log do plugin ou pedir ao autor um índice para a consulta.

## Quando o problema é mesmo o plano

Trocar de plano resolve falta de recurso, não consulta ruim. Uma consulta que lê a `wp_postmeta` inteira sem índice continua lenta em máquina maior, só um pouco menos. Use a listagem para decidir:

| O que a listagem mostra | Leitura provável | Próximo passo |
|---|---|---||
| Uma consulta longa e várias esperando lock | Consulta específica | Achar o plugin ou relatório |
| A mesma consulta lenta voltando sempre | Código ou falta de índice | Corrigir a origem, não o plano |
| Muitas consultas curtas e diferentes, nenhuma longa | Volume de acesso | Cache de página, depois avaliar recurso |
| Nada relevante na lista, site lento mesmo assim | Gargalo fora do banco | Olhar PHP, disco e rede |

Só a terceira linha é argumento honesto para upgrade, e mesmo ela vem depois de cache. Se você fizer o upgrade com o problema na primeira ou na segunda linha, o cliente paga mais e o travamento volta.

## O que padronizar nos sites da agência para o próximo travamento

- Garanta acesso ao banco de cada cliente antes do incidente: usuário, senha e forma de conexão no seu cofre de senhas.
- Salve a consulta ordenada por `TIME` como snippet. Ela serve para qualquer site.
- No incidente, rode a listagem duas ou três vezes e copie o `Info` da thread mais antiga. Se só houver threads esperando metadata lock, rode sem o filtro de `Sleep` e procure a conexão ociosa mais antiga do mesmo usuário.
- `KILL QUERY` só na consulta culpada, ou `KILL` na conexão ociosa que segura o lock. Valide que a fila andou.
- Anote horário, usuário do banco e texto da consulta num registro do cliente.
- Identifique a origem pelo prefixo da tabela, pela `meta_key` e pelo log de acesso.
- Corrija a origem (configurar, agendar, limpar ou substituir o plugin) antes de falar em plano.
- Se repetir, ative o slow query log para ter o histórico que a listagem não guarda.

Frase pronta para o cliente: "O site travou porque uma consulta gerada pelo plugin X ficou presa no banco e bloqueou as outras. Encerrei só essa consulta, o site voltou, e agora vou ajustar o plugin para ela não se repetir. Por enquanto não há motivo para trocar de plano."

