Monitores
Heartbeat (Push)

Heartbeat (Push)

O monitor Heartbeat inverte a lógica de monitoramento: em vez do TheAlert verificar seu serviço periodicamente, é o seu serviço que envia um ping para o TheAlert. Se o ping não chegar dentro do intervalo esperado, o monitor vai para DOWN.

Quando usar Heartbeat

Use o Heartbeat quando você precisa monitorar processos que não têm uma interface HTTP acessível externamente, como:

  • Cron jobs e tarefas agendadas
  • Workers de processamento de filas (Sidekiq, BullMQ, Celery, etc.)
  • Scripts de backup automático
  • Processos de sincronização de dados
  • Tarefas de manutenção noturna
  • Qualquer processo que deve rodar periodicamente

O Heartbeat é ideal para detectar quando um cron job parou de rodar — uma das falhas mais silenciosas e difíceis de detectar em sistemas de produção.

Como funciona

Seu serviço → POST /push/SEU-TOKEN → TheAlert registra ping

Se nenhum ping chegar em (intervalo × 1.5): monitor vai para DOWN
  1. Você cria um monitor do tipo PUSH no TheAlert
  2. Recebe uma URL de token única para este monitor
  3. Seu serviço faz um POST para essa URL ao final de cada execução
  4. O TheAlert aguarda o próximo ping dentro do período intervalo × 1.5
  5. Se o ping não chegar → DOWN e alerta disparado

Exemplo de tempo limite

Intervalo configuradoTempo máximo para próximo ping
1 minuto1,5 minutos
5 minutos7,5 minutos
1 hora1,5 horas
24 horas36 horas

Configuração

Crie o monitor

No TheAlert: Novo Monitor → Tipo: Heartbeat (Push) → configure o nome e o intervalo esperado entre os pings.

Copie o token URL

Após salvar, o TheAlert exibe a URL de push única:

https://api.thealert.io/push/SEU-TOKEN-AQUI

Adicione ao seu serviço

Integre o envio do ping ao final da execução do seu processo.

Exemplos de integração

Linux Cron (bash)

# Verificar disponibilidade a cada minuto
* * * * * /usr/bin/curl -s -X POST https://api.thealert.io/push/SEU-TOKEN
 
# Backup diário às 3h — faz backup e avisa o TheAlert
0 3 * * * /scripts/backup.sh && curl -s -X POST https://api.thealert.io/push/SEU-TOKEN
⚠️

No segundo exemplo, o ping só é enviado se o backup suceder (&&). Se o backup falhar, o ping não é enviado e o TheAlert detecta a ausência. Este é o comportamento correto — você quer ser alertado quando o backup falhar.

Node.js

// Worker que roda a cada minuto
const HEARTBEAT_URL = 'https://api.thealert.io/push/SEU-TOKEN'
 
async function runJob() {
  try {
    // ... lógica do seu worker
    await processQueue()
 
    // Envia ping de sucesso
    await fetch(HEARTBEAT_URL, { method: 'POST' })
  } catch (err) {
    console.error('Job falhou:', err)
    // NÃO envia ping — TheAlert vai detectar a ausência
  }
}
 
setInterval(runJob, 60_000)

Python

import requests
import time
 
HEARTBEAT_URL = 'https://api.thealert.io/push/SEU-TOKEN'
 
while True:
    try:
        # ... lógica do seu worker
        process_queue()
 
        # Envia ping de sucesso
        requests.post(HEARTBEAT_URL, timeout=5)
    except Exception as e:
        print(f'Job falhou: {e}')
        # NÃO envia ping — TheAlert vai detectar a ausência
 
    time.sleep(60)

PHP

<?php
// Executa tarefa
$success = runMyTask();
 
if ($success) {
    // Envia ping apenas em caso de sucesso
    file_get_contents(
        'https://api.thealert.io/push/SEU-TOKEN',
        false,
        stream_context_create([
            'http' => ['method' => 'POST', 'ignore_errors' => true]
        ])
    );
}

Systemd Timer (Linux)

Se você usa systemd timers em vez de cron:

# /etc/systemd/system/meu-job.service
[Unit]
Description=Meu Job Periódico
 
[Service]
Type=oneshot
ExecStart=/scripts/meu-job.sh
ExecStartPost=/usr/bin/curl -s -X POST https://api.thealert.io/push/SEU-TOKEN

GitHub Actions

jobs:
  backup:
    runs-on: ubuntu-latest
    steps:
      - name: Executar backup
        run: ./scripts/backup.sh
 
      - name: Notificar TheAlert
        if: success()
        run: curl -s -X POST https://api.thealert.io/push/SEU-TOKEN

Resposta da API

A URL de push retorna sempre:

{ "ok": true }

Você pode ignorar a resposta ou verificar o status HTTP (200 = recebido).

Rate limit

O endpoint de push aceita no máximo 10 requisições por minuto por token. Para crons que rodam com frequência maior, considere aumentar o intervalo configurado no monitor.

Casos de uso avançados

Monitorar que backup não falhou silenciosamente

#!/bin/bash
# backup.sh
 
pg_dump producao > /backups/db-$(date +%Y%m%d).sql
 
if [ $? -eq 0 ]; then
    curl -s -X POST https://api.thealert.io/push/SEU-TOKEN
    echo "Backup concluído com sucesso"
else
    echo "ERRO: Backup falhou!"
    exit 1
fi

Monitorar worker de fila

Se seu worker de fila parar de processar (sem falhar explicitamente), o ping para de chegar e o TheAlert alerta após intervalo × 1.5.

Monitorar sincronização de dados

Processos de ETL ou sincronização com APIs externas que devem rodar periodicamente.

Próximos passos

WebSocketVisão Geral