Análise de registros da Web e de aplicações em grande escala

Todo servidor HTTP — Apache, Nginx, Caddy — grava uma linha em um registro de acesso para cada solicitação. Entender a estrutura dessas linhas é a base de todo trabalho de análise de registros.

Uma linha típica do Formato de Registro Combinado (CLF) tem esta aparência:

• IP do cliente — quem fez a solicitação
• Carimbo de data e hora — quando isso aconteceu
• Linha da solicitação — método, caminho e protocolo
• Código de status — resposta HTTP (200, 404, 500…)
• Bytes enviados — tamanho do corpo da resposta
• Referenciador — página de origem
• Agente do usuário — texto que identifica o navegador ou bot

Exemplo de linha de /var/log/nginx/access.log:

192.168.1.10 - alice [11/Jun/2026:14:32:01 +0000] "GET /api/orders HTTP/1.1" 200 1482 "-" "curl/7.88.1"

Em grande escala, esses arquivos chegam a milhões de linhas por dia. O objetivo desta lição é extrair, filtrar e agregar campos deles com eficiência usando ferramentas padrão do BASH.

Antes de escrever qualquer cadeia de processamento, examine o registro para entender seu formato. tail permite acompanhar um fluxo ativo; grep o restringe imediatamente às linhas relevantes.

Padrões comuns:

• tail -n 1000 access.log — últimas 1000 linhas
• tail -f access.log — acompanhar em tempo real
• tail -f access.log | grep '" 5' — apenas erros 5xx à medida que chegam

A principal ideia é que grep compara com a linha inteira, portanto é importante fixar corretamente o padrão. Comparar ' 500 ' (com espaços) evita que você corresponda acidentalmente a um caminho de URL que contenha a sequência 500.

cut divide cada linha usando um delimitador e exibe os campos selecionados. No Formato de Registro Combinado, o código de status fica no campo 9 quando a divisão é feita nos espaços — mas as aspas ao redor da linha da solicitação fazem com que seja mais seguro contar a partir de uma referência conhecida.

Um truque confiável: como a linha da solicitação está sempre entre aspas, o código de status é sempre o primeiro item depois das aspas de fechamento do campo da solicitação. Usar cut -d'"' -f3 isola tudo depois das aspas da solicitação; em seguida, um segundo cut -d' ' -f2 seleciona o código de status.

Esse uso do cut em duas etapas é um padrão clássico para registros CLF — rápido e sem dependências externas.

awk é mais poderoso que cut porque pode acumular estado entre as linhas. O padrão idiomático para contar ocorrências é usar uma matriz associativa indexada pelo valor que você deseja analisar.

No CLF, o campo $9 (indexado a partir de 1 e delimitado por espaços) contém o código de status. awk processa cada linha, incrementa um contador e depois exibe um resumo ordenado no bloco END.

Por que preferir awk a cut | sort | uniq -c? Porque awk faz isso em uma única passagem, sem ordenar primeiro o arquivo inteiro — algo essencial quando o registro tem centenas de gigabytes.

Uma das tarefas operacionais mais comuns é descobrir quais IPs de clientes estão gerando mais erros. Isso combina filtragem (apenas linhas de erro) com extração de campos (o IP no campo 1).

A estratégia da cadeia de processamento:

• Use awk para filtrar pelo intervalo do código de status e extrair o IP em uma única etapa — evite uma passagem separada com grep
• Encadeie com sort | uniq -c | sort -rn | head para obter rapidamente uma visão dos N primeiros

Esse padrão é rápido o suficiente para ser executado em um arquivo de registro de 10 GB em um único servidor, sem carregar o arquivo na memória.

Servidores de aplicações (Rails, Gunicorn, Express com morgan etc.) costumam registrar a duração das solicitações. O Nginx pode ser configurado para emitir $request_time como um campo adicional no fim de cada linha.

Exemplo de formato de registro personalizado do Nginx em nginx.conf:

log_format timed '$remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent" rt=$request_time';

Quando a latência estiver no registro, você poderá usar awk para calcular a média, o máximo e aproximações de percentis em milhões de solicitações, sem carregar os dados em um banco de dados.

Uma única média oculta a latência da cauda. Um histograma revela a distribuição — mostra se a maioria das solicitações é rápida e algumas são muito lentas (cauda longa) ou se a distribuição é uniforme.

O truque é agrupar cada valor em um intervalo arredondado usando aritmética inteira dentro do awk. Multiplicar por 1000 (convertendo segundos em milissegundos) e depois usar a divisão inteira produz limites de intervalo bem definidos.

Isso produz um histograma textual que você pode ler diretamente em um terminal, o que costuma ser mais rápido do que enviar dados ao Grafana para uma investigação rápida.

O campo do agente do usuário (campo 6 ao dividir em ") identifica os clientes. Rastreadores, coletores e bots mal-intencionados costumam poluir suas métricas e inflar as contagens de erros. Filtrá-los resulta em uma visão mais clara do tráfego de usuários reais.

Assinaturas comuns de bots: bot, crawler, spider, curl, python-requests, Googlebot, Bingbot.

Use grep -iv (inversão sem distinção entre maiúsculas e minúsculas) para excluir bots conhecidos ou use awk para dividir em " e comparar diretamente o campo UA.

Saber quais endpoints recebem mais tráfego — e geram mais erros — ajuda a priorizar a otimização e o planejamento de capacidade. O caminho da solicitação fica dentro do campo entre aspas.

Divida em ", use o campo 2 (a linha da solicitação) e depois remova o método e o protocolo para isolar o caminho. Para APIs com parâmetros no caminho, como /users/12345, talvez você também queira normalizar os IDs para /users/:id usando sed ou um padrão mais complexo de awk.

A análise de passagem única mais poderosa combina vários campos ao mesmo tempo: endpoint, código de status e, opcionalmente, latência. Matrizes associativas de awk indexadas por valores compostos tornam isso simples e rápido.

O padrão abaixo conta erros 5xx por endpoint em uma única passagem — sem arquivos temporários e sem ordenações intermediárias até o final. Essa é a abordagem usada em scripts de observabilidade de produção quando você precisa de respostas em menos de um minuto sobre um registro grande.

Na maioria dos servidores, os registros são rotacionados diariamente. Os arquivos mais antigos são compactados com gzip como access.log.1.gz, access.log.2.gz etc. As ferramentas padrão não conseguem lê-los diretamente, mas duas abordagens funcionam bem:

• zcat — descompacta para a saída padrão e envia para sua cadeia de processamento
• zgrep — executa grep diretamente dentro dos arquivos gzip, sem extraí-los

Para analisar uma semana inteira de registros que inclua arquivos descompactados e compactados, use a substituição de processo ou concatene com zcat. O trecho abaixo processa os últimos 7 arquivos rotacionados e o registro ativo atual em uma única invocação de awk — não são necessários arquivos temporários.

Você está escrevendo uma linha única de awk para filtrar apenas respostas HTTP 4xx de um registro de acesso padrão do Nginx no Combined Log Format (delimitado por espaços, com a linha de requisição entre aspas). Qual número de campo identifica corretamente o código de status HTTP?

Nesta lição, você construiu um conjunto completo de ferramentas para analisar registros da Web e de aplicações em grande escala usando apenas utilitários padrão do BASH.

Principais técnicas abordadas:

• Estrutura em primeiro lugar — o Combined Log Format tem uma disposição previsível dos campos; conhecê-la permite dividi-lo de forma confiável com cut -d'"' ou referências a campos do awk.
• Extração do código de status — awk '{ count[$9]++ }' conta todos os códigos em uma única passagem; filtre com $9 ~ /^5/ para encontrar erros do servidor.
• Análise de latência — analise o campo personalizado rt= com awk para calcular médias, valores máximos e intervalos de histogramas sem nenhuma ferramenta externa.
• Análise de clientes e robôs — divida em " com -F'"' para acessar o campo User-Agent; use um pipeline com grep -iv para excluir robôs antes de agregar os dados.
• Normalização de endpoints — use gsub(/\/[0-9]+/, "/:id") dentro do awk para agrupar caminhos parametrizados antes da contagem.
• Registros rotacionados — combine cat e zcat em um subshell para enviar todos os arquivos de rotação em uma única passagem pelo pipeline.

Esses padrões podem ser combinados: você pode encadear filtragem, extração, normalização e agregação em um único pipeline que processa centenas de milhões de linhas em hardware comum. Domine essas primitivas e raramente precisará de um serviço dedicado de agregação de registros para investigar incidentes pontuais.