0Pricing
Linux Command Line & Bash Scripting Mastery · Aula

Acompanhamento de registros em tempo real e alertas por transmissão

Acompanhe e filtre fluxos de registros ativos para disparar alertas no instante em que surgirem padrões de erro.

Acompanhamento de registros em tempo real e alertas por transmissão é uma aula grátis de Linux Command Line & Bash Scripting Mastery no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Linux Command Line & Bash Scripting Mastery, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Linux Command Line & Bash Scripting Mastery inclui 4 aulas no total.

Por que acompanhar registros em tempo real é importante

Em sistemas de produção, os arquivos de registro crescem continuamente. Esperar até que um problema seja relatado para examinar os registros significa que o tempo de inatividade já causou prejuízos. O acompanhamento de registros em tempo real permite observar os eventos no momento em que são gravados, possibilitando uma resposta imediata a falhas, eventos de segurança e degradação de desempenho.

  • Servidores Web gravam uma linha por requisição — os erros aparecem instantaneamente
  • Serviços de aplicação registram rastreamentos de pilha no momento em que uma exceção ocorre
  • Sistemas de autenticação registram tentativas de login malsucedidas em tempo real

A ferramenta Unix fundamental para isso é tail -f, combinada com utilitários de filtragem e alertas para transformar fluxos de registros brutos em sinais acionáveis.

tail -f: acompanhando um registro ao vivo

tail -f (acompanhar) mantém o arquivo aberto e exibe novas linhas à medida que são adicionadas. É a ferramenta de registros em tempo real mais simples e disponível de forma mais universal.

Padrões de uso comuns:

  • tail -f /var/log/syslog — acompanha o registro do sistema
  • tail -n 50 -f app.log — exibe as últimas 50 linhas e depois acompanha o arquivo
  • tail -f /var/log/nginx/access.log — acompanha as requisições do nginx ao vivo

Pressione Ctrl+C para parar. O processo permanece conectado até que você o cancele ou o terminal seja fechado.

#!/usr/bin/env bash
# Simulate a live log and follow it
LOGFILE='/tmp/demo_app.log'

# Write a header
echo '[INFO] Application started' >> "$LOGFILE"

# In a real scenario you would run:
# tail -f "$LOGFILE"
# Below we demonstrate tail showing the last 3 lines then exit
tail -n 3 "$LOGFILE"

tail -F: sobrevivendo à rotação de registros

Muitos sistemas rotacionam os arquivos de registro à meia-noite ou quando atingem um limite de tamanho. Quando isso acontece, o arquivo original é renomeado (por exemplo, app.log.1) e um novo app.log é criado. Com tail -f, você continua lendo silenciosamente o arquivo antigo renomeado e perde toda a nova saída.

tail -F (F maiúsculo) resolve esse problema ao monitorar o nome do arquivo, e não o descritor de arquivo. Quando o arquivo desaparece e reaparece, tail -F o reabre automaticamente e continua acompanhando-o.

  • Prefira sempre tail -F a tail -f em scripts de produção
  • Funciona com o logrotate, o newsyslog e os controladores de registros do Docker que rotacionam arquivos
# Follow nginx access log, surviving log rotation
tail -F /var/log/nginx/access.log

# Follow multiple files simultaneously
tail -F /var/log/nginx/access.log /var/log/nginx/error.log

Filtrando o fluxo com grep

Acompanhar um registro movimentado sem filtragem é desgastante — um servidor Web ativo pode gravar centenas de linhas por segundo. Envie a saída de tail -F para grep para isolar apenas os padrões que interessam a você.

Principais opções do grep para fluxos:

  • --line-buffered — libera cada linha correspondente imediatamente, em vez de armazená-la em buffer; é obrigatório em pipelines, caso contrário a saída poderá atrasar ou ser perdida
  • -i — correspondência que não diferencia maiúsculas de minúsculas
  • -E — expressão regular estendida para alternância (error|warn|crit)
  • -v — inverte a correspondência (exclui linhas)
# Show only ERROR and WARN lines from a live application log
tail -F /var/log/myapp/app.log | grep --line-buffered -Ei 'error|warn|critical'

# Follow nginx and exclude health-check requests
tail -F /var/log/nginx/access.log | grep --line-buffered -v '/health'

Adicionando marcas de tempo e contexto com awk

Às vezes, as linhas de registro não têm o contexto que ajuda na triagem. Você pode enriquecer o fluxo em tempo real usando awk — adicionando uma marca de tempo local, extraindo campos ou reformulando a saída para facilitar a leitura.

O awk também funciona no modo de fluxo (com buffer por linha) quando recebe dados por um pipeline, o que torna seguro usá-lo em pipelines ao vivo sem opções adicionais.

# Prepend a reception timestamp to every ERROR line
tail -F /var/log/myapp/app.log | \
  grep --line-buffered -i 'error' | \
  awk '{ print strftime("[%Y-%m-%d %H:%M:%S]"), $0; fflush() }'

# Extract HTTP status code (field 9) and URL (field 7) from nginx combined log
tail -F /var/log/nginx/access.log | \
  awk '{ print $9, $7; fflush() }' | \
  grep --line-buffered '^5'

Enviando alertas com webhooks do Slack

Filtrar é apenas metade do trabalho — depois que você detecta um padrão de erro, precisa notificar alguém. Um webhook de entrada do Slack permite enviar uma mensagem para um canal com uma única chamada de curl, sem exigir o SDK do Slack nem credenciais além da URL do webhook.

O padrão é: filtre o fluxo e, para cada linha correspondente, envie um HTTP POST.

#!/usr/bin/env bash
# Real-time alert: send every ERROR line to a Slack channel
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'

tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
  payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
  curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
    -d "$payload" "$WEBHOOK_URL"
done

Limitando a taxa de alertas para evitar ruído

Uma avalanche de registros pode gerar milhares de linhas de erro por minuto. Enviar uma mensagem do Slack por linha inundará o canal e causará fadiga de alertas. Você precisa de limitação de taxa — dispare o alerta e suprima as notificações seguintes durante um período de espera.

Isso é obtido com um simples arquivo de marca temporal: registre quando o último alerta foi enviado e não o dispare se o período de espera ainda não tiver terminado.

#!/usr/bin/env bash
# Alert on ERROR lines but no more than once every 60 seconds
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
COOLDOWN=60
LAST_ALERT_FILE='/tmp/last_alert_ts'

tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
  now=$(date +%s)
  last=0
  [ -f "$LAST_ALERT_FILE" ] && last=$(cat "$LAST_ALERT_FILE")

  if (( now - last >= COOLDOWN )); then
    echo "$now" > "$LAST_ALERT_FILE"
    payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
    curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
      -d "$payload" "$WEBHOOK_URL"
    echo "[$(date)] Alert sent: $line"
  else
    echo "[$(date)] Suppressed (cooldown): $line"
  fi
done

Contando rajadas de erros com uma janela deslizante

Às vezes, uma única linha de erro não é significativa — mas 20 erros em 30 segundos representam um problema grave. Um contador de janela deslizante permite disparar alertas somente quando um limite da taxa de erros é excedido, reduzindo falsos positivos.

A técnica armazena a marca temporal da época de cada evento correspondente em um arquivo temporário e depois conta quantos estão dentro da janela antes de decidir se deve emitir um alerta.

#!/usr/bin/env bash
# Alert when more than 10 errors occur within any 60-second window
LOGFILE='/var/log/myapp/app.log'
WINDOW=60
THRESHOLD=10
TS_FILE='/tmp/error_timestamps'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'

tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
  now=$(date +%s)
  echo "$now" >> "$TS_FILE"

  # Keep only timestamps within the window
  cutoff=$(( now - WINDOW ))
  tmp=$(mktemp)
  awk -v c="$cutoff" '$1 > c' "$TS_FILE" > "$tmp" && mv "$tmp" "$TS_FILE"

  count=$(wc -l < "$TS_FILE")
  if (( count > THRESHOLD )); then
    msg="*[BURST ALERT]* ${count} errors in ${WINDOW}s — last: ${line}"
    curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
      -d "{\"text\":\"$msg\"}" "$WEBHOOK_URL"
    # Clear to avoid re-alerting until next burst
    > "$TS_FILE"
  fi
done

journalctl -f: acompanhando diários do systemd

Em sistemas Linux modernos (RHEL, Ubuntu 20.04+, Debian 10+), os serviços gravam no diário do systemd, em vez de arquivos de texto simples. journalctl -f é o equivalente a tail -F para o diário.

Opções úteis:

  • -u myapp.service — acompanha apenas uma unidade específica
  • -p err — filtra por prioridade (emerg, alert, crit, err, warning, notice, info, debug)
  • --since '5 min ago' — começa a partir de um horário relativo
  • -o json — gera JSON estruturado para análise por máquina
# Follow only error-and-above entries for nginx
journalctl -f -u nginx.service -p err

# Stream journal as JSON and extract MESSAGE field with jq
journalctl -f -u myapp.service -o json | \
  jq --unbuffered -r 'select(.PRIORITY <= "3") | .MESSAGE'

multitail e monitoramento multiorigem com cores

Quando você precisa observar várias fontes de registros simultaneamente, o multitail divide o terminal em painéis — cada um acompanhando um arquivo ou comando diferente — com codificação opcional por cores conforme o padrão.

Se o multitail não estiver instalado, uma alternativa leve e totalmente desenvolvida em Bash consiste em prefixar cada fluxo com o nome da fonte e mesclá-los em uma única visualização.

# multitail: watch nginx access + error + app log in split panes
# (requires: apt install multitail  or  brew install multitail)
multitail /var/log/nginx/access.log /var/log/nginx/error.log /var/log/myapp/app.log

# Pure-Bash alternative — merge three streams with labeled prefixes
(
  tail -F /var/log/nginx/access.log | sed --unbuffered 's/^/[nginx-access] /' &
  tail -F /var/log/nginx/error.log  | sed --unbuffered 's/^/[nginx-error]  /' &
  tail -F /var/log/myapp/app.log    | sed --unbuffered 's/^/[myapp]        /' &
  wait
)

Construindo um serviço de alertas autocontido

Reunindo tudo o que foi visto nesta lição, um serviço de alertas pronto para produção deve:

  • Acompanhar o arquivo de registro de forma robusta com tail -F
  • Filtrar padrões críticos com grep com buffer
  • Limitar a taxa de notificações para evitar fadiga de alertas
  • Registrar sua própria atividade para que você possa auditar o que foi enviado
  • Executar como um processo em segundo plano gerenciado pelo systemd ou por um supervisor

O script abaixo é um serviço mínimo, mas completo, que você pode colocar em /usr/local/bin/ e gerenciar com o systemd.

#!/usr/bin/env bash
# log_alert_daemon.sh — tail a log and fire Slack alerts with cooldown
set -euo pipefail

LOGFILE=${1:-'/var/log/myapp/app.log'}
PATTERN=${2:-'error|critical|fatal'}
WEBHOOK_URL=${SLACK_WEBHOOK_URL:?'Set SLACK_WEBHOOK_URL env var'}
COOLDOWN=${ALERT_COOLDOWN:-120}
DAEMON_LOG='/var/log/log_alert_daemon.log'
LAST_SENT_FILE='/tmp/log_alert_last_sent'

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$DAEMON_LOG"; }

log "Starting alert daemon: watching $LOGFILE for pattern: $PATTERN"

tail -F "$LOGFILE" | grep --line-buffered -Ei "$PATTERN" | while IFS= read -r line; do
  now=$(date +%s)
  last=0
  [ -f "$LAST_SENT_FILE" ] && last=$(cat "$LAST_SENT_FILE")

  if (( now - last >= COOLDOWN )); then
    echo "$now" > "$LAST_SENT_FILE"
    msg=$(printf '{"text":"*[ALERT]* %s\n%s"}' "$(hostname)" "$line")
    if curl -s -o /dev/null -w '%{http_code}' -X POST \
         -H 'Content-Type: application/json' -d "$msg" "$WEBHOOK_URL" | grep -q '^200$'; then
      log "Alert sent: $line"
    else
      log "Alert FAILED to send: $line"
    fi
  else
    log "Suppressed (cooldown ${COOLDOWN}s): $line"
  fi
done

Verificação de conhecimentos: pipelines de registros em fluxo

Teste sua compreensão sobre o acompanhamento de registros em tempo real e os alertas em fluxo.

Um pipeline do Bash acompanha um arquivo de registro e envia um alerta do Slack para cada linha correspondente. Durante uma avalanche de registros, 3.000 linhas de erro são gravadas em 10 segundos. Qual única alteração impede melhor que o script inunde o canal do Slack com 3.000 mensagens?

Resumo da lição: acompanhamento de registros em tempo real e alertas em fluxo

Nesta lição, você construiu do zero um pipeline completo de observabilidade de registros em tempo real:

  • tail -F acompanha um arquivo de registro pelo nome, sobrevivendo à rotação de registros — prefira-o sempre a tail -f em produção
  • grep --line-buffered filtra o fluxo ao vivo sem introduzir latência; sempre adicione essa opção aos comandos grep usados em pipelines
  • awk com fflush() enriquece cada linha com marcas de tempo ou campos extraídos de forma segura para fluxos
  • Webhooks do Slack via curl entregam alertas com um único HTTP POST — nenhum SDK é necessário
  • Arquivos de espera evitam a fadiga de alertas durante avalanches de registros ao impor um intervalo mínimo entre notificações
  • Contadores de janela deslizante detectam rajadas de erros (alertas baseados em taxa), em vez de reagir a cada linha individual
  • journalctl -f é o equivalente nativo do systemd ao tail -F, com filtragem de prioridade e saída JSON integradas
  • Um script de serviço de alertas autocontido combina todos esses padrões e pode ser gerenciado pelo systemd para garantir confiabilidade em produção

Essas primitivas se combinam para formar a base de qualquer pipeline personalizado de observabilidade — nenhum agente de terceiros é necessário.

Perguntas Frequentes

A aula “Acompanhamento de registros em tempo real e alertas por transmissão” é grátis?

Sim — o texto completo de “Acompanhamento de registros em tempo real e alertas por transmissão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Linux Command Line & Bash Scripting Mastery, atualize para CoddyKit PRO. O curso de Linux Command Line & Bash Scripting Mastery inclui 4 aulas no total.

O que vou aprender em “Acompanhamento de registros em tempo real e alertas por transmissão”?

Acompanhe e filtre fluxos de registros ativos para disparar alertas no instante em que surgirem padrões de erro. Você pratica Linux Command Line & Bash Scripting Mastery com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Linux Command Line & Bash Scripting Mastery?

Nenhuma experiência prévia é necessária. Linux Command Line & Bash Scripting Mastery no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Acompanhamento de registros em tempo real e alertas por transmissão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Linux Command Line & Bash Scripting Mastery?

Sim. Cada aula de Linux Command Line & Bash Scripting Mastery inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Análise de registros da Web e de aplicações em grande escala
  2. Acompanhamento de registros em tempo real e alertas por transmissão
  3. Consulta ao journald com journalctl em scripts
  4. Cálculo de métricas e histogramas a partir de fluxos de registros
← Voltar para Linux Command Line & Bash Scripting Mastery