Criando integrações personalizadas com webhooks

Integrações Personalizadas com Webhooks

Use webhooks para integrar a SuperPing com qualquer sistema, desde ERPs até ferramentas customizadas.

O que são webhooks?

Webhooks são notificações HTTP automáticas enviadas quando eventos específicos acontecem.

Eventos disponíveis

• monitor.down: Monitor detectou que site está fora do ar
• monitor.up: Monitor detectou que site voltou ao ar
• monitor.slow: Monitor detectou resposta lenta
• monitor.ssl_expiring: Certificado SSL expirando em breve
• monitor.created: Novo monitor foi criado
• monitor.deleted: Monitor foi removido

Estrutura do payload

{
  "event": "monitor.down",
  "timestamp": "2024-01-15T10:30:00Z",
  "monitor": {
    "id": "abc123",
    "name": "Site Principal",
    "url": "https://meusite.com",
    "type": "https",
    "status": "down"
  },
  "check": {
    "response_time": null,
    "status_code": null,
    "error": "Connection timeout",
    "location": "São Paulo, BR"
  },
  "user": {
    "id": "user456",
    "email": "usuario@empresa.com"
  }
}
      

Configurando webhook

1. No dashboard, vá em "Integrações"
2. Clique em "Adicionar Webhook"
3. Configure a URL do seu endpoint
4. Selecione os eventos desejados
5. Configure autenticação (opcional)
6. Teste a configuração

Exemplo: Integração com sistema de tickets

Endpoint em Node.js/Express

const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhook/superping', async (req, res) => {
  const { event, monitor, check } = req.body;
  
  try {
    if (event === 'monitor.down') {
      // Criar ticket no sistema
      await criarTicket({
        titulo: `Site ${monitor.name} fora do ar`,
        descricao: `
          URL: ${monitor.url}
          Erro: ${check.error}
          Horário: ${new Date().toLocaleString()}
        `,
        prioridade: 'alta',
        categoria: 'infraestrutura'
      });
      
      console.log(`Ticket criado para ${monitor.name}`);
    }
    
    if (event === 'monitor.up') {
      // Fechar ticket relacionado
      await fecharTicket(monitor.id);
      console.log(`Ticket resolvido para ${monitor.name}`);
    }
    
    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Erro no webhook:', error);
    res.status(500).json({ error: 'Erro interno' });
  }
});

async function criarTicket(dados) {
  // Integração com seu sistema de tickets
  // Exemplo: JIRA, ServiceNow, sistema próprio
}

async function fecharTicket(monitorId) {
  // Buscar e fechar ticket relacionado
}

app.listen(3000);
      

Exemplo: Integração com sistema ERP

Endpoint em Python/Flask

from flask import Flask, request, jsonify
import requests
import json

app = Flask(__name__)

@app.route('/webhook/superping', methods=['POST'])
def handle_webhook():
    data = request.json
    event = data.get('event')
    monitor = data.get('monitor')
    
    try:
        if event == 'monitor.down':
            # Notificar ERP sobre indisponibilidade
            erp_response = requests.post(
                'https://erp.empresa.com/api/incidents',
                headers={'Authorization': 'Bearer TOKEN_ERP'},
                json={
                    'type': 'system_down',
                    'system': monitor['name'],
                    'url': monitor['url'],
                    'impact': 'high',
                    'category': 'infrastructure'
                }
            )
            
            print(f"Incidente registrado no ERP: {erp_response.status_code}")
            
        elif event == 'monitor.up':
            # Atualizar status no ERP
            requests.patch(
                f"https://erp.empresa.com/api/incidents/{monitor['id']}",
                headers={'Authorization': 'Bearer TOKEN_ERP'},
                json={'status': 'resolved'}
            )
            
        return jsonify({'success': True}), 200
        
    except Exception as e:
        print(f"Erro: {e}")
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(port=5000)
      

Exemplo: Integração com sistema de notificação personalizado

Endpoint em PHP

 '+5511999999999',
            'mensagem' => "ALERTA: {$monitor['name']} está fora do ar!"
        ]);
        
        // Enviar email personalizado
        enviarEmailCustomizado([
            'para' => 'admin@empresa.com',
            'assunto' => "🚨 {$monitor['name']} fora do ar",
            'template' => 'alerta_critico',
            'dados' => $monitor
        ]);
        
        // Registrar no log do sistema
        registrarLog("CRITICAL", "Monitor {$monitor['name']} down");
    }
    
    if ($event === 'monitor.up') {
        enviarSMS([
            'para' => '+5511999999999',
            'mensagem' => "✅ {$monitor['name']} voltou ao ar!"
        ]);
        
        registrarLog("INFO", "Monitor {$monitor['name']} recovered");
    }
    
    echo json_encode(['success' => true]);
    
} catch (Exception $e) {
    http_response_code(500);
    echo json_encode(['error' => $e->getMessage()]);
}

function enviarSMS($dados) {
    // Integração com provedor de SMS
}

function enviarEmailCustomizado($dados) {
    // Sistema de email personalizado
}

function registrarLog($nivel, $mensagem) {
    file_put_contents(
        'logs/superping.log',
        date('Y-m-d H:i:s') . " [{$nivel}] {$mensagem}
",
        FILE_APPEND
    );
}
?>
      

Segurança do webhook

Validação de assinatura

const crypto = require('crypto');

function validarAssinatura(payload, signature, secret) {
    const expectedSignature = crypto
        .createHmac('sha256', secret)
        .update(payload)
        .digest('hex');
    
    return crypto.timingSafeEqual(
        Buffer.from(signature),
        Buffer.from(expectedSignature)
    );
}

app.post('/webhook/superping', (req, res) => {
    const signature = req.headers['x-superping-signature'];
    const payload = JSON.stringify(req.body);
    
    if (!validarAssinatura(payload, signature, WEBHOOK_SECRET)) {
        return res.status(401).json({ error: 'Assinatura inválida' });
    }
    
    // Processar webhook...
});
      

Rate limiting

const rateLimit = require('express-rate-limit');

const webhookLimiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutos
    max: 100, // máximo 100 requests por IP
    message: 'Muitas requests, tente novamente mais tarde'
});

app.use('/webhook', webhookLimiter);
      

Retry e confiabilidade

A SuperPing implementa retry automático:

• Tenta 3 vezes em caso de falha
• Intervalos: 1min, 5min, 30min

Testando webhooks

Usando ngrok para testes locais

# Instalar ngrok
npm install -g ngrok

# Expor porta local
ngrok http 3000

# URL pública será algo como:
# https://abc123.ngrok.io
      

Endpoint de teste simples

app.post('/webhook/test', (req, res) => {
    console.log('Webhook recebido:', JSON.stringify(req.body, null, 2));
    res.json({ status: 'received' });
});