Envoyez des signaux réguliers pour prouver que votre application fonctionne correctement
Le heartbeat (qu'on pourrait traduire, littéralement - mais pas très élégamment - par « ping de vie ») est un mécanisme de surveillance qui repose sur un principe simple mais puissant : votre application envoie régulièrement un signal à un service de monitoring pour prouver qu'elle est vivante et fonctionne correctement. L'absence de ce signal déclenche une alerte, permettant de détecter des pannes qui passeraient autrement inaperçues.
Contrairement au monitoring HTTP classique qui teste la disponibilité d'une URL depuis l'extérieur, le heartbeat est émis depuis l'intérieur de votre application. Cette approche "inside-out" permet de surveiller des processus qui n'exposent pas d'interface HTTP : crons, workers de queue, scripts batch, synchronisations de données. Si le processus ne s'exécute pas ou plante avant de terminer, aucun ping n'est envoyé et vous êtes alerté.
Cette technique est particulièrement efficace pour les processus qui s'exécutent périodiquement et dont l'échec peut passer inaperçu pendant des jours : sauvegardes automatiques, imports de données, génération de rapports, nettoyage de fichiers temporaires. Le heartbeat garantit que vous serez alerté si un de ces processus critiques cesse de fonctionner.
Le mécanisme du heartbeat repose sur quatre composants qui travaillent ensemble pour garantir une surveillance fiable de vos processus.
Le positionnement du ping dans votre code est crucial pour garantir une surveillance efficace. Voici les différentes situations et les bonnes pratiques associées.
Voici des exemples complets d'intégration du heartbeat dans différents langages et contextes. Tous les exemples incluent une gestion des erreurs appropriée et des bonnes pratiques.
#!/bin/bash
# Backup script avec heartbeat
PING_URL="https://ping.monitao.com/p/VOTRE_TOKEN"
# Exécuter le backup
/usr/bin/mysqldump -u root -p'password' mydb > /backup/db.sql
RESULT=$?
# Ping uniquement si le backup a réussi
if [ $RESULT -eq 0 ]; then
# Vérifier que le fichier n'est pas vide
if [ -s /backup/db.sql ]; then
curl -fsS --retry 3 --max-time 10 "$PING_URL" > /dev/null
echo "Backup OK, ping envoyé"
else
echo "Fichier backup vide, pas de ping"
exit 1
fi
else
echo "Erreur backup, pas de ping"
exit 1
fiCe script vérifie non seulement le code de retour de mysqldump mais aussi que le fichier généré n'est pas vide. Le curl utilise --retry 3 pour réessayer en cas d'échec réseau temporaire, et --max-time 10 pour éviter de bloquer indéfiniment.
generateReports();
// Validation: au moins quelques rapports générés
if ($count === 0) {
$this->warn('Aucun rapport généré');
// On ping quand même car le job s'est exécuté
}
// Ping avec métriques
Http::timeout(10)->retry(3)->post(
'https://ping.monitao.com/p/VOTRE_TOKEN',
['duration' => $this->executionTime, 'count' => $count]
);
$this->info("Terminé: {$count} rapports");
} catch (\Exception $e) {
report($e);
// Pas de ping = alerte MoniTao
return 1;
}
}
}L'exemple Laravel utilise le client HTTP intégré avec retry automatique. Les métriques (durée, nombre d'éléments) sont envoyées avec le ping pour un monitoring enrichi. L'exception interrompt le script avant le ping.
import requests
import sys
from datetime import datetime
PING_URL = "https://ping.monitao.com/p/VOTRE_TOKEN"
def ping_monitao(duration_ms=None, status="success"):
"""Envoie un ping à MoniTao avec retry"""
payload = {"status": status}
if duration_ms:
payload["duration"] = duration_ms
for attempt in range(3):
try:
response = requests.post(
PING_URL,
json=payload,
timeout=10
)
if response.ok:
return True
except requests.RequestException:
continue
return False
def main():
start = datetime.now()
try:
# Votre logique métier
process_data()
sync_database()
generate_reports()
# Calcul durée et ping
duration = (datetime.now() - start).total_seconds() * 1000
ping_monitao(duration_ms=duration)
print(f"Terminé en {duration:.0f}ms")
except Exception as e:
print(f"Erreur: {e}", file=sys.stderr)
# Pas de ping = alerte
sys.exit(1)
if __name__ == "__main__":
main()Le script Python inclut une fonction réutilisable avec retry intégré. La durée d'exécution est calculée et envoyée avec le ping, permettant de suivre les tendances de performance dans l'historique MoniTao.
const https = require('https');
const PING_URL = 'https://ping.monitao.com/p/VOTRE_TOKEN';
async function pingMonitao(metrics = {}) {
return new Promise((resolve) => {
const data = JSON.stringify(metrics);
const url = new URL(PING_URL);
const req = https.request({
hostname: url.hostname,
path: url.pathname,
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': data.length
},
timeout: 10000
}, (res) => resolve(res.statusCode < 400));
req.on('error', () => resolve(false));
req.write(data);
req.end();
});
}
async function main() {
const start = Date.now();
try {
await processQueue();
await syncData();
const duration = Date.now() - start;
await pingMonitao({ duration, items: processedCount });
console.log(`Done in ${duration}ms`);
} catch (error) {
console.error('Error:', error.message);
process.exit(1);
}
}
main();L'exemple Node.js utilise le module https natif sans dépendance externe. La fonction pingMonitao retourne une promesse et peut être facilement intégrée dans n'importe quel script async/await.
Ces recommandations vous aideront à tirer le meilleur parti du heartbeat tout en évitant les pièges courants.
Ces erreurs fréquentes peuvent réduire l'efficacité de votre surveillance ou générer des fausses alertes.
Le heartbeat s'applique à de nombreuses situations. Voici les cas les plus courants avec leurs spécificités d'implémentation.
Les workers qui traitent des messages de queue (Redis, RabbitMQ, SQS) sont des candidats idéaux pour le heartbeat. Un worker peut mourir silencieusement (OOM, crash, conteneur évincé) sans que personne ne s'en aperçoive. Envoyez un ping toutes les 1-5 minutes dans la boucle principale du worker. Si le worker meurt, les pings cessent et vous êtes alerté avant que la queue ne se remplisse dangereusement.
Les sauvegardes sont critiques mais leur échec est souvent silencieux : le cron ne s'exécute pas, le script plante, l'espace disque est insuffisant. Créez un heartbeat quotidien avec une période de grâce de 4-6 heures. Pingez après avoir vérifié l'intégrité du backup (fichier non vide, checksum valide). Vous saurez immédiatement si une sauvegarde n'a pas eu lieu.
Les jobs de synchronisation entre systèmes (CRM ↔ ERP, base de données ↔ data warehouse) doivent s'exécuter régulièrement pour maintenir la cohérence. Un arrêt de sync non détecté cause des divergences qui s'accumulent et deviennent coûteuses à corriger. Pingez après chaque cycle de synchronisation réussi, en incluant le nombre d'enregistrements synchronisés dans les métriques.
MoniTao simplifie la mise en place de heartbeats avec une interface intuitive et des fonctionnalités avancées pour tous vos besoins de surveillance.
Un ping raté ponctuellement ne déclenche pas d'alerte grâce à la période de grâce. Utilisez des retries (2-3 tentatives) dans votre code pour absorber les problèmes réseau temporaires. Si les échecs persistent au-delà de la période de grâce, vous serez alerté, ce qui est généralement souhaitable car cela indique un problème plus large.
Oui, MoniTao accepte un payload JSON avec le ping. Vous pouvez envoyer la durée d'exécution, le nombre d'éléments traités, un statut détaillé, ou toute autre métrique pertinente. Ces données sont stockées dans l'historique et permettent d'analyser les tendances et de détecter des dégradations progressives.
Créez un heartbeat distinct pour chaque environnement. Chaque heartbeat a sa propre URL de ping et ses propres paramètres d'alerte. Vous pouvez organiser vos heartbeats par tags ou projets dans MoniTao pour une meilleure visibilité.
L'impact est négligeable. Un appel HTTP avec timeout de 5 secondes ajoute au maximum 5 secondes à votre script, et en pratique beaucoup moins (quelques dizaines de millisecondes). Pour les jobs très fréquents (toutes les minutes), vous pouvez utiliser un appel asynchrone qui n'attend pas la réponse.
Oui, absolument. Si votre job vérifie une condition (emails à envoyer, fichiers à traiter) et ne trouve rien à faire, il doit quand même pinger. Le ping prouve que le job s'est exécuté et a vérifié la condition. Sans ping, vous ne pouvez pas distinguer "rien à faire" de "job pas lancé du tout".
Les deux méthodes fonctionnent avec MoniTao. GET est plus simple (URL seule) et suffit pour un ping basique. POST permet d'envoyer des données supplémentaires (métriques, statut) dans le corps de la requête. Utilisez POST si vous voulez enrichir votre monitoring avec des métriques.
Le heartbeat est une technique simple mais extrêmement efficace pour surveiller les processus qui ne peuvent pas être testés de l'extérieur. En quelques lignes de code, vous pouvez transformer n'importe quel script, cron ou worker en processus surveillé, avec une alerte garantie en cas d'arrêt inattendu.
Avec MoniTao, l'intégration du heartbeat prend moins de 5 minutes. Créez un heartbeat, copiez l'URL, ajoutez un appel HTTP à la fin de votre script, et vous êtes protégé contre les pannes silencieuses. Ne découvrez plus vos problèmes quand il est trop tard - surveillez proactivement avec le heartbeat.
Commencez gratuitement, sans carte bancaire.